☰
composition
composition
Functions
S
hook, monadic after
Bird: Starling
BQN: ⟜
Haskell: <*>
D
composition of one binary function f and one unary function g...
Bird: Dove
BQN: ⟜
Haskell:
create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`
B1
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
B3
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
Functions
S
hook, monadic after
Bird: Starling
BQN: ⟜
Haskell: <*>
D
composition of one binary function f and one unary function g...
Bird: Dove
BQN: ⟜
Haskell:
create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`
B1
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
B3
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
S
hook, monadic after
Bird: Starling
BQN: ⟜
Haskell: <*>
hook, monadic after
Bird: Starling
BQN: ⟜
Haskell: <*>
D
composition of one binary function f and one unary function g...
Bird: Dove
BQN: ⟜
Haskell:
create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`
B1
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
B3
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
D
composition of one binary function f and one unary function g...
Bird: Dove
BQN: ⟜
Haskell:
composition of one binary function f and one unary function g...
Bird: Dove
BQN: ⟜
Haskell:
create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`
B1
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
B3
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`
create `"instance[T]"` where `T` is the dynamic type of `a`
B1
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
B3
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
B1
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
B3
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
B3
triple compositor
Bird: Becard
BQN:
Haskell:
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
?
Constant cancellator?
Bird: ?
BQN: ˙
Constant cancellator?
Bird: ?
BQN: ˙
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
§D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
§
D2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) => Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
§
(V
type
, U1 type
, U2 type
, T1 type
, T2 type
, f Binary V U1 U2, g Unary U1 T1, h Unary U2 T2) =>
Binary V T1 T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) => Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
§
(V
type
, U1 type
, U2 type
, T1 type
, T2 type
, f Binary V U1 U2, g Binary U1 T1 T2, h Binary U2 T1 T2) =>
Binary V T1 T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
O
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
O
Bird: Owl
BQN: ?
Haskell: ?
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
T
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip idType Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
V
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip id
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip id
Type Functions
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
name of this type, including type parameters, e.g. 'option (list i32)'.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
see https://mlochbaum.github.io/BQN/tutorial/combinator.html
Talk at Strange Loop 2016 by Amar Shah: Point-Free or Die: Tacit Programming in Haskell and Beyond
https://www.youtube.com/watch?v=seVSlKazsNk
Talk at CppNorth 2023 by Conor Hoekstra: Function Composition in Programming Languages - Conor Hoekstra - CppNorth 2023
https://www.youtube.com/watch?v=JELcdZLre3s
Paper by Conor Hoekstra: Combinatory Logic and Combinators in Array Languages
https://web.archive.org/web/20220617020347id_/https://dl.acm.org/doi/pdf/10.1145/3520306.3534504
BQN tutorial: https://mlochbaum.github.io/BQN/tutorial/index.html
Talk for Fullstack Academy by Gabriel Lebec: Lambda Calculus - Fundamentals of Lambda Calculus & Functional
Pragramming in JavaScript
https://www.youtube.com/watch?v=3VQ382QG-y4
David C Keenan
To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction
https://dkeenan.com/Lambda/
Haskell package data.aviary.birds:
https://hackage.haskell.org/package/data-aviary-0.4.0/docs/Data-Aviary-Birds.html
Bird names from Raymond M Smullyan. 2000. To Mock a Mockingbird: and other
logic puzzles including an amazing adventure in combinatory logic. Oxford
University Press, USA.
Combinator birds: https://www.angelfire.com/tx4/cus/combinator/birds.html