119 people like it.
Like the snippet!

The Haskell const function

The const function is simple, but you can use it to make your code more legible. In this example we convert a unary function to a function of arity 2 (that ignores the second argument). Also by using the flip function from Haskell (which is equally easy to define) you can ignore the first argument.

Declarations

1: 
2: 
3: 
4: 
5:

// The const function
let ct a _ = a

// The flip function (not used in this snippet)
let flip f x y = f y x

Use case

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14:

// Code taken from a toy interpreter

type Exp = 
    // ...
    // Lambdas are expressed as F# an function that takes a list of Exps and an env
    | Lambda of (Exp list -> Env -> Exp)
    // ...
and Env = (string * Exp) list

// Built-ins receive evaluated arguments so they don't care about the env.
// By composing the function we get with ct we're basically converting a function
// of arity 1 to a function of arity 2 that just ignores its second argument

let builtin f = Lambda (f >> ct)

val ct : a:'a -> 'b -> 'a

Full name: Script.ct

val a : 'a

val flip : f:('a -> 'b -> 'c) -> x:'b -> y:'a -> 'c

Full name: Script.flip

val f : ('a -> 'b -> 'c)

val x : 'b

val y : 'a

type Exp = | Lambda of (Exp list -> Env -> Exp)

Full name: Script.Exp

union case Exp.Lambda: (Exp list -> Env -> Exp) -> Exp

type 'T list = List<'T>

Full name: Microsoft.FSharp.Collections.list<_>

type Env = (string * Exp) list

Full name: Script.Env

Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string

val builtin : f:(Exp list -> Exp) -> Exp

Full name: Script.builtin

val f : (Exp list -> Exp)

Previous Version Raw view Test code New version

More information

Link:	http://fssnip.net/19
Posted:	13 years ago
Author:	Alex Muscar
Tags:	haskell functions