concepts.json

[
		{
			"name": "Forward function application",
			"description": "Apply / Pipe",
			"index": 0,
			"notes": "Applies an argument to a function. The Apply/Pipe-forward operator lets you pass an intermediate result onto the next function. The result of the left argument is passed as an argument to the right function. Data-oriented approach, more idiomatic in F# and Elm.",
			"languages": [
				{
					"name": "Purescript",
					"code": "#, applyFlipped"
				},
				{
					"name": "Haskell",
					"code": "&"
				},
				{
					"name": "Elm",
					"code": "|>",
          "example": ["(|>) : a -> (a -> b) -> b",
											"",
											"employeeBossStreet : Employee -> String",
											"employeeBossStreet employee =   employee",
											"    |> boss",
											"    |> address",
											"    |> street",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\" : String."
										]
				},				{
					"name": "F#",
					"code": "|>",
					"example": ["( |> ) : 'T1 -> ('T1 -> 'U) -> 'U ",
											"",
											"let employeeBossStreet (employee: Employee) : string = ",
											"  employee",
											"    |> boss",
											"    |> address",
											"    |> street",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">val it : string = \"DummyEmployeeBossStreetName\""
										]
				}
			],
			"links": [
				{
					"url": "https://pursuit.purescript.org/packages/purescript-prelude/2.1.0/docs/Prelude#v:(#)",
					"description": "Purescript # reference"
				},
				{
					"url": "http://stackoverflow.com/questions/1457140/haskell-composition-vs-fs-pipe-forward-operator",
					"description": "Stack Overflow discussion"
				},
				{
					"url": "http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#|>",
					"description": "Elm Basics - (|>)"
				},
				{
					"url": "https://www.reddit.com/r/haskell/comments/3mttyh/elms_operator/",
					"description": "A discussion on idiomatic operators in Elm and Haskell"
				}
			]
		},
		{
			"name": "Backward function application",
			"description": "Apply / Pipe",
			"index": 1,
			"notes": "Applies a function to an argument. Can be used to avoid parentheses and improve readability. The result of the right argument is applied to the left argument.",
			"languages": [
				{
					"name": "Purescript",
					"code": "$, apply",
					"example": ["apply :: forall a b. (a -> b) -> a -> b",
											"apply f x = f x",
											"",
											"--without operator",
											"employeeBossStreet :: Employee -> String",
											"employeeBossStreet employee =",
											"  street (address (boss employee))",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\"",
											"",
											"--with operator",
											"employeeBossStreet :: Employee -> String",
											"employeeBossStreet employee =",
											"  street $ address $ boss employee",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\""
										]
				},
				{
					"name": "Haskell",
					"code": "$",
					"example": ["($) :: (a -> b) -> a -> b",
											"F x = f x",
											"",
											"= street (address (boss employee))",
											"= street $ address $ boss employee"
										]
				},
				{
					"name": "Elm",
					"code": "<|",
					"example": ["(<|) : (a -> b) -> a -> b",
											"",
											"--without operator",
											"employeeBossStreet : Employee -> String",
											"employeeBossStreet employee = ",
											"  street (address (boss employee))",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\" : String. ",
											"",
											"-- with operator",
											"employeeBossStreet : Employee -> String",
											"employeeBossStreet employee = ",
											"  street <| address <| boss employee",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\" : String."
										]
				},				{
					"name": "F#",
					"code": "<|",
        "example": [  "( <| ) : ('T -> 'U) -> 'T -> 'U",
											"",
											"//without operator",
											"let employeeBossStreet (employee: Employee) : string =",
											"  street (address (boss employee))",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">val it : string = \"DummyEmployeeBossStreetName\" ",
											"",
											"//with operator",
											"let employeeBossStreet (employee: Employee) : string =",
											"  street <| address <| boss employee",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">val it : string = \"DummyEmployeeBossStreetName\""
										]
				}
			],
			"links": [
				{
					"url": "https://pursuit.purescript.org/packages/purescript-prelude/2.1.0/docs/Prelude#v:($)",
					"description": "Purescript $ reference"
				},
				{
					"url": "http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#<|",
					"description": "Elm Basics - (<|)"
				},
				{
					"url": "https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/index",
					"description": "F# functions reference"
				},
				{
					"url": "https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/symbol-and-operator-reference/",
					"description": "F# operator reference"
				}
			]
		},
		{
			"name": "Composition - forward",
			"description": "Forward/right",
			"notes": "Creating a new, combined function by piping the result of the left argument to the right argument. A function-oriented approach, combining functions first, actual values input later.",
			"index": 2,
			"languages": [
				{
					"name": "Purescript",
					"code": ">>>, composeFlipped",
					"example": ["composeFlipped :: forall a b c d. Semigroupoid a => a b c -> a c d -> a b d",
											"",
											"employeeBossStreet :: (Employee -> String)",
											"employeeBossStreet =",
											"  boss >>> address >>> street",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\""
										]

				},
				{
					"name": "Haskell",
					"code": ">>>",
					"example": ["employeeBossStreet = (boss >>> address >>> street) employee"
										]
				},
				{
					"name": "Elm",
					"code": ">>",
					"example": ["(>>) : (a -> b) -> (b -> c) -> a -> c",
											"",
											"employeeBossStreet : (Employee -> String)",
											"employeeBossStreet =",
											"  boss >> address >> street",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\" : String."
										]
				},
				{
					"name": "F#",
					"code": ">>",
					"example": ["(>>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c",
											"",
											"let employeeBossStreet : (Employee -> string) =",
											"  boss >> address >> street",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">val it : string = \"DummyEmployeeBossStreetName\""
										]
				}
			],
			"links": [
				{
					"url": "https://wiki.haskell.org/Function_composition",
					"description": "Haskell wiki"
				},
				{
					"url": "https://fsharpforfunandprofit.com/posts/function-composition/",
					"description": "F# for fun and profilt - function composition"
				},
				{
					"url": "http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#>>",
					"description": "Elm - basics >>"
				}
			]
		},
		{
			"name": "Composition - backward",
			"description": "Backward/left",
			"notes": "Creating a new, combined function by piping the result of the right argument to the left argument. A function-oriented approach, combining functions first, actual values input later. More idiomatic in Purescript/Haskell. The Control.Arrow module in Haskell base has (<<<) in addition to (>>>). For function arrows, (<<<) specializes to (.).",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "<<<, compose",
					"example": ["compose :: forall a b c. (b -> c) -> (a -> b) -> a -> c",
											"",
											"employeeBossStreet :: (Employee -> String)",
											"employeeBossStreet =",
											"  street <<< address <<< boss",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\""
										]
				},
				{
					"name": "Haskell",
					"code": "<<<, .",
					"example": ["employeeBossStreet = (street . address . boss) employee",
								"",
								"employeeBossStreet = (street <<< address <<< boss) employee"
										]
				},
				{
					"name": "Elm",
					"code": "<<",
					"example": ["(<<) : (b -> c) -> (a -> b) -> a -> c",
											"",
											"employeeBossStreet : (Employee -> String)",
											"employeeBossStreet =",
											"  street << address << boss",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">\"DummyEmployeeBossStreetName\" : String."
										]
				},
				{
					"name": "F#",
					"code": "<<",
					"example": ["(<<) : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c",
											"",
											"let employeeBossStreet : (Employee -> string) =",
											"  street << address << boss",
											"",
											"employeeBossStreet dummyEmployeeRecord",
											">val it : string = \"DummyEmployeeBossStreetName\""
										]
				}
			],
			"links": [
				{
					"url": "https://wiki.haskell.org/Function_composition",
					"description": "Haskell wiki"
				},
				{
					"url": "https://fsharpforfunandprofit.com/posts/function-composition/",
					"description": "F# for fun and profilt - function composition"
				},
				{
					"url": "http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#<<",
					"description": "Elm - basics (<<)"
				}
			]
		},
		{
			"name": "Unit type",
			"description": "Empty",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "Unit"
				},
				{
					"name": "Haskell",
					"code": "()"
				},
				{
					"name": "Elm",
					"code": "()"
				},				{
					"name": "F#",
					"code": "()"
				}
			]
		},
		{
			"name": "Anonymous function",
			"description": "Lambda",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "\\x -> x + 1"
				},
				{
					"name": "Haskell",
					"code": "\\x -> x + 1"
				},
				{
					"name": "Elm",
					"code": "\\x -> x + 1"
				},				{
					"name": "F#",
					"code": "fun x -> x + 1"
				}
			]
		},
		{
			"name": "Identity function",
			"description": "",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "identity"
				},
				{
					"name": "Haskell",
					"code": "id"
				},
				{
					"name": "Elm",
					"code": "identity"
				},				{
					"name": "F#",
					"code": "id"
				}
			]
		},
		{
			"name": "Tuple",
			"description": "Definition",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "Tuple a b"
				},
				{
					"name": "Haskell",
					"code": "(Int, String)"
				},
				{
					"name": "Elm",
					"code": "(Int, String)"
				},				{
					"name": "F#",
					"code": "int * string"
				}
			]
		},
		{	"name": "Tuple",
			"description": "Usage",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "Tuple 2 \"Test\""
				},
				{
					"name": "Haskell",
					"code": "(2, \"Test\")"
				},
				{
					"name": "Elm",
					"code": "(2, \"Test\")"
				},				{
					"name": "F#",
					"code": "(2, \"Test\")"
				}
			]
		},
		{
			"name": "Record types",
			"description": "",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "type Point = { x :: Int, y :: Int}"
				},
				{
					"name": "Haskell",
					"code": "data Point = Point { x :: Int, y :: Int}"
				},
				{
					"name": "Elm",
					"code": "type alias Point = { x : Int, y : Int}"
				},				{
					"name": "F#",
					"code": "type Point = {\r x : int; y : int}"
				}
			]
		},
		{
			"name": "Union types",
			"description": "Sum types / Discriminated unions / Algebraic data types (ADT)",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "data Shape = Circle Point Int | Line Point Point"
				},
				{
					"name": "Haskell",
					"code": "data Shape = Circle Point Int | Line Point Point"
				},
				{
					"name": "Elm",
					"code": "type Shape = Circle Point Int | Line Point Point"
				},				{
					"name": "F#",
					"code": "type Shape = Circle of Point * int | Line of Point * Point"
				}
			]
		},
		{
			"name": "Maybe/Option",
			"description": "",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "data Maybe a = Just a | Nothing"
				},
				{
					"name": "Haskell",
					"code": "data Maybe a = Just a | Nothing"
				},
				{
					"name": "Elm",
					"code": "type Maybe a = Just a | Nothing"
				},				{
					"name": "F#",
					"code": "type Option<'a> = | Some of 'a | None"
				}
			]
	 	},
		{
			"name": "Either / Result",
			"description": "",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "data Either a b = Left a | Right b"
				},
				{
					"name": "Haskell",
					"code": "data Either a b = Left a | Right b"
				},
				{
					"name": "Elm",
					"code": "type Result error value = Ok value | Err error"
				},				{
					"name": "F#",
					"code": "(in F# 4.1) type Result<'T,'TError> = | Ok of 'T | Error of 'TError"
				}
			]
		},
		{
			"name": "Functor map",
			"description": "Map",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "<$>, map"
				},
				{
					"name": "Haskell",
					"code": "<$>, fmap"
				},
				{
					"name": "Elm",
					"code": "map"
				},				{
					"name": "F#",
					"code": "map"
				}
			]
		},
		{
			"name": "Functor apply",
			"description": "Apply",
			"notes" : "*andMap is not core in Elm, but is often used in Packages.",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "<*>, apply"
				},
				{
					"name": "Haskell",
					"code": "<*>"
				},
				{
					"name": "Elm",
					"code": "andMap(*notes)"
				},				{
					"name": "F#",
					"code": "apply"
				}
			],
			"links": [
				{
					"url": "http://klaftertief.github.io/elm-search/?q=andMap",
					"description": "Elm - External packages using andMap"
				}
			]
		},
		{
			"name": "Functor lift",
			"description": "",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": "liftN"
				},
				{
					"name": "Haskell",
					"code": "liftN"
				},
				{
					"name": "Elm",
					"code": "mapN"
				},				{
					"name": "F#",
					"code": "mapN"
				}
			]
		},
		{
			"name": "Bind",
			"description": "",
			"index": 3,
			"languages": [
				{
					"name": "Purescript",
					"code": ">>=, bind"
				},
				{
					"name": "Haskell",
					"code": ">>="
				},
				{
					"name": "Elm",
					"code": "andThen"
				},				{
					"name": "F#",
					"code": "bind"
				}
			]
		},
		{
			"name": "Comments",
			"description": "",
			"index": 3,
			"notes": "Single line comments, block comments and documentation comments.",
			"languages": [
				{
					"name": "Purescript",
					"code": "-- Line {- Block -} --| Documentation",
          "example": ["-- A single line comment",
											"{-",
											"  Comment",
											"  continued comment {- Nested block -}",
											"-}",
											"-- | Comments that start with a pipe character, |, are considered documentation, and will appear in the output of tools like psc-docs and Pursuit.",
											"-- | Adds two numbers",
											"-- This comment does not start with a pipe and will not be part of the documentation",
											"add :: Int -> Int -> Int",
											"add x y = x + y"
										]
				},
				{
					"name": "Haskell",
					"code": "-- Line {- Block -} --| Documentation",
          "example": ["-- A single line comment",
											"{-",
											"  Comment",
											"  continued comment {- Nested block -}",
											"-}",
											"-- | Comments that start with a pipe character, |, are considered documentation, and will appear in the output of documentation tools.",
											"-- | Adds two numbers",
											"add :: Int -> Int -> Int",
											"add x y = x + y"
										]
				},
				{
					"name": "Elm",
					"code": "-- Line {- Block -}",
          "example": ["-- A single line comment",
											"{-",
											"  Comment",
											"  continued comment {- Nested block -}",
											"-}",
											"{- Block comments that start with a pipe character, |, are ",
											"considered documentation, and will",
											"appear in the output package documentation.",
											"",
											"@docs add",
											"To output documentation, @docs keyword precedes a comma-separated list of values",
											"The @docs add, will document the comment preceeding the add function.",
											"-}",
											"{-|",
											"Adds two numbers",
											"-}",
											"add : Int -> Int -> Int",
											"add x y = x + y"
										]
				},				{
					"name": "F#",
					"code": "// Line (* Block *)",
          "example": ["// A single line comment",
											"(*",
											"  Comment",
											"  continued comment",
											"*)",
											"// XML documentation comments come after ///",
											"/// Adds two numbers",
											"let add (x:int) (y:int) = x + y"
										]
				}
			],
			"links": [
				{
					"url": "https://github.com/purescript/documentation/blob/master/language/Syntax.md#comments",
					"description": "Purescript comments"
				},
				{
					"url": "http://elm-lang.org/docs/syntax#comments",
					"description": "Elm comments"
				},
				{
					"url": "http://package.elm-lang.org/help/documentation-format",
					"description": "Elm package documentation"
				},
				{
					"url": "https://dungpa.github.io/fsharp-cheatsheet/",
					"description": "F# Cheatsheet"
				},
				{
					"url": "https://wiki.haskell.org/Reference_card#Comments",
					"description": "Haskell reference card"
				}
			]
		},
		{
			"name": "Type annotation",
			"description": "Function definition",
			"index": 3,
			"notes": "Annotating types can in many situations be omitted due to type inference, but can improve readability.",
			"languages": [
				{
					"name": "Purescript",
					"code": "add :: Int -> Int -> Int",
          "example": ["add :: Int -> Int -> Int",
											"add x y = x + y",
											"",
											"-- Using universally quantified types (generic)",
											"flip :: forall a b c. (a -> b -> c) -> b -> a -> c",
											"flip f b a = f a b"
										]
				},
				{
					"name": "Haskell",
					"code": "add :: Int -> Int -> Int",
          "example": ["add :: Int -> Int -> Int",
											"add x y = x + y",
											"",
											"-- Using generic types (any type)",
											"flip :: (a -> b -> c) -> b -> a -> c",
											"flip f b a = f a b"
										]
				},
				{
					"name": "Elm",
					"code": "add : Int -> Int -> Int",
          "example": ["add : Int -> Int -> Int",
											"add x y = x + y",
											"",
											"-- Using generic types (any type)",
											"flip : (a -> b -> c) -> b -> a -> c",
											"flip f b a = f a b"
										]
				},				{
					"name": "F#",
					"code": "let add (x:int) (y:int) : int = x + y",
          "example": ["let add (x:int) (y:int) : int = x + y"
										]
				}
			],
			"links": [
				{
					"url": "http://elm-lang.org/docs/syntax#type-annotations",
					"description": "Elm type annnotations"
				},
				{
					"url": "https://fsharpforfunandprofit.com/posts/function-signatures/",
					"description": "F# for fun and profit function signatures"
				},
				{
					"url": "http://learnyouahaskell.com/types-and-typeclasses",
					"description": "Haskell types and typeclasses"
				}
			]
		},
		{
			"name": "Generic types",
			"description": "Type variables",
			"index": 3,
			"notes": "Generic functions and types enable you to write code that works with a variety of types without repeating the code for each type. Type variables/generic types can have names longer than one character, but usually given one character names.",
			"languages": [
				{
					"name": "Purescript",
					"code": "forall a b.",
          "example": ["-- Any lowercase identifier can be used, like a, msg.",
											"flip :: forall a b c. (a -> b -> c) -> b -> a -> c"
										]
				},
				{
					"name": "Haskell",
					"code": "a b",
          "example": ["-- Any lowercase identifier can be used, like a, msg.",
											"flip :: (a -> b -> c) -> b -> a -> c"
										]
				},
				{
					"name": "Elm",
					"code": "a b",
          "example": ["-- Any lowercase identifier can be used, like a, msg.",
											"flip : (a -> b -> c) -> b -> a -> c"
										]
				},				{
					"name": "F#",
					"code": "'a 'b 'C",
          "example": ["// Generics are identified by ' and can use upper/lowercase, like 'a, 'Msg.",
											"val flip = ('a -> 'b -> 'c) -> 'b -> 'a -> 'c",
											"// Can also use <type-parameter in angle brackets:",
											"let function2<'T> x y =",
											"    printfn \"%A, %A\" x y"
										]
				}
			],
			"links": [
				{
					"url": "https://www.tutorialspoint.com/fsharp/fsharp_generics.htm",
					"description": "F# Generics"
				},
				{
					"url": "https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/generics/",
					"description": "F# Generics - Microsoft F# language reference"
				},
				{
					"url": "https://www.elm-tutorial.org/en/01-foundations/03-functions-2.html",
					"description": "Elm tutorial - functions"
				}
			]
		}
	]