Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.canton.network/llms.txt

Use this file to discover all available pages before exploring further.

​
Prelude

The pieces that make up the Daml language.

​
Module Snapshot

Lifecycle

Stable.

Notices

Status: active Introduced in: 3.4.9 Removed in: - Warnings: 0 Deprecations: 0 Deprecated since: -

​
Data Types

​
data AnyChoice

Existential choice type that can wrap an arbitrary choice. Constructors:
  • AnyChoice | Field | Type | Description | | :---- | :--- | :---------- | | getAnyChoice | Any | | | getAnyChoiceTemplateTypeRep | TemplateTypeRep | |
Instances:
  • instance Eq AnyChoice
  • instance Ord AnyChoice

​
data AnyContractKey

Existential contract key type that can wrap an arbitrary contract key. Constructors:
  • AnyContractKey | Field | Type | Description | | :---- | :--- | :---------- | | getAnyContractKey | Any | | | getAnyContractKeyTemplateTypeRep | TemplateTypeRep | |
Instances:
  • instance Eq AnyContractKey
  • instance Ord AnyContractKey

​
data AnyTemplate

Existential template type that can wrap an arbitrary template. Constructors:
  • AnyTemplate | Field | Type | Description | | :---- | :--- | :---------- | | getAnyTemplate | Any | |
Instances:
  • instance Eq AnyTemplate
  • instance Ord AnyTemplate

​
data TemplateTypeRep

Unique textual representation of a template Id. Constructors:
  • TemplateTypeRep | Field | Type | Description | | :---- | :--- | :---------- | | getTemplateTypeRep | TypeRep | |
Instances:
  • instance Eq TemplateTypeRep
  • instance Ord TemplateTypeRep

​
data Down a

The Down type can be used for reversing sorting order. For example, sortOn (\x -> Down x.field) would sort by descending field. Constructors:
  • Down a
Instances:
  • instance Action Down
  • instance Applicative Down
  • instance Functor Down
  • instance Eq a => Eq (Down a)
  • instance Ord a => Ord (Down a)
  • instance Show a => Show (Down a)

​
type Implements = (HasInterfaceTypeRep i, HasToInterface t i, HasFromInterface t i)

(Daml-LF >= 1.15) Constraint that indicates that a template implements an interface.

​
data AnyException

A wrapper for all exception types.
Deprecated: Exceptions are deprecated, prefer failWithStatus, and avoid using catch.
Deprecated: Use -Wno-deprecated-exceptions to disable this warning.
Instances:
  • instance HasFromAnyException AnyException
  • instance HasMessage AnyException
  • instance HasToAnyException AnyException

​
data ContractId a

The ContractId a type represents an ID for a contract created from a template a. You can use the ID to fetch the contract, among other things. Instances:
  • instance Eq (ContractId a)
  • instance Ord (ContractId a)
  • instance Show (ContractId a)

​
data Date

The Date type represents a date, for example date 2007 Apr 5. The bounds for Date are 0001-01-01 and 9999-12-31. Instances:
  • instance Eq Date
  • instance Ord Date
  • instance Bounded Date
  • instance Enum Date
  • instance Show Date

​
data Map a b

The Map a b type represents an associative array from keys of type a to values of type b. It uses the built-in equality for keys. Import DA.Map to use it. Instances:
  • instance Ord k => Foldable (Map k)
  • instance Ord k => Monoid (Map k v)
  • instance Ord k => Semigroup (Map k v)
  • instance GetField map (Set k) (Map k ())
  • instance SetField map (Set k) (Map k ())
  • instance Ord k => Traversable (Map k)
  • instance Ord k => Functor (Map k)
  • instance (Ord k, Eq v) => Eq (Map k v)
  • instance (Ord k, Ord v) => Ord (Map k v)
  • instance (Show k, Show v) => Show (Map k v)

​
data Party

The Party type represents a party to a contract. Instances:
  • instance HasFromHex (Optional Party)
  • instance HasToHex Party
  • instance IsParties Party
  • instance IsParties (Optional Party)
  • instance IsParties (NonEmpty Party)
  • instance IsParties (Set Party)
  • instance IsParties [Party]
  • instance Eq Party
  • instance Ord Party
  • instance Show Party

​
data TextMap a

The TextMap a type represents an associative array from keys of type Text to values of type a. Instances:
  • instance Foldable TextMap
  • instance Monoid (TextMap b)
  • instance Semigroup (TextMap b)
  • instance GetField meta FailureStatus (TextMap Text)
  • instance SetField meta FailureStatus (TextMap Text)
  • instance Traversable TextMap
  • instance Functor TextMap
  • instance Eq a => Eq (TextMap a)
  • instance Ord a => Ord (TextMap a)
  • instance Show a => Show (TextMap a)

​
data Time

The Time type represents a specific datetime in UTC, for example time (date 2007 Apr 5) 14 30 05. The bounds for Time are 0001-01-01T00:00:00.000000Z and 9999-12-31T23:59:59.999999Z. Instances:
  • instance Eq Time
  • instance Ord Time
  • instance Bounded Time
  • instance Show Time

​
data Update a

The Update a type represents an Action to update or query the ledger, before returning a value of type a. Examples include create and fetch. Instances:
  • instance CanAssert Update
  • instance ActionCatch Update
  • instance ActionThrow Update
  • instance ActionFailWithStatus Update
  • instance CanAbort Update
  • instance HasTime Update
  • instance Action Update
  • instance ActionFail Update
  • instance Applicative Update
  • instance Functor Update

​
data Optional a

The Optional type encapsulates an optional value. A value of type Optional a either contains a value of type a (represented as Some a), or it is empty (represented as None). Using Optional is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error. The Optional type is also an Action. It is a simple kind of error Action, where all errors are represented by None. A richer error Action could be built using the Data.Either.Either type. Constructors:
  • None
  • Some a
Instances:
  • instance HasFromHex (Optional Party)
  • instance HasFromHex (Optional Int)
  • instance HasFromHex (Optional Text)
  • instance Foldable Optional
  • instance Action Optional
  • instance ActionFail Optional
  • instance Applicative Optional
  • instance IsParties (Optional Party)
  • instance Traversable Optional
  • instance Functor Optional
  • instance Eq a => Eq (Optional a)
  • instance Ord a => Ord (Optional a)
  • instance Show a => Show (Optional a)

​
data Archive

The data type corresponding to the implicit Archive choice in every template. Constructors:
  • Archive (no fields)
Instances:
  • instance Eq Archive
  • instance Show Archive

​
type Choice = (Template t, HasExercise t c r, HasToAnyChoice t c r, HasFromAnyChoice t c r)

Constraint satisfied by choices.

​
type Template = (HasTemplateTypeRep t, HasToAnyTemplate t, HasFromAnyTemplate t)

​
type TemplateKey = (Template t, HasKey t k, HasLookupByKey t k, HasFetchByKey t k, HasMaintainer t k, HasToAnyContractKey t k, HasFromAnyContractKey t k)

Constraint satisfied by template keys.

​
Typeclasses

​
class Action m => CanAssert m

Constraint that determines whether an assertion can be made in this context. Methods:
  • assertFail : Text -> m t Abort since an assertion has failed. In an Update, Scenario, or Script context this will throw an AssertionFailed exception. In an Either Text context, this will return the message as an error.
Instances:
  • instance CanAssert Update
  • instance CanAssert (Either Text)

​
class HasInterfaceTypeRep i

(Daml-LF >= 1.15) Exposes the interfaceTypeRep function. Available only for interfaces.

​
class HasToInterface t i

(Daml-LF >= 1.15) Exposes the toInterface and toInterfaceContractId functions.

​
class HasFromInterface t i

(Daml-LF >= 1.15) Exposes fromInterface and fromInterfaceContractId functions. Methods:
  • fromInterface : i -> Optional t (Daml-LF >= 1.15) Attempt to convert an interface value back into a template value. A None indicates that the expected template type doesn’t match the underyling template type for the interface value. For example, fromInterface @MyTemplate value will try to convert the interface value value into the template type MyTemplate.

​
class HasInterfaceView i v

Methods:
  • _view : i -> v

​
class HasTime m

The HasTime class is for where the time is available: Update Methods:
  • getTime : HasCallStack => m Time Get the current time.
Instances:
  • instance HasTime Update

​
class Action m => CanAbort m

The CanAbort class is for Action s that can be aborted. Methods:
  • abort : Text -> m a Abort the current action with a message.
Instances:
  • instance CanAbort Update
  • instance CanAbort (Either Text)

​
class Functor f => Applicative f

Methods:
  • pure : a -> f a Lift a value.
  • <*> : f (a -> b) -> f a -> f b Sequentially apply the function. A few functors support an implementation of <*> that is more efficient than the default one.
  • liftA2 : (a -> b -> c) -> f a -> f b -> f c Lift a binary function to actions. Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.
  • *> : f a -> f b -> f b Sequence actions, discarding the value of the first argument.
  • <* : f a -> f b -> f a Sequence actions, discarding the value of the second argument.
Instances:
  • instance Applicative (-> r)
  • instance Applicative (State s)
  • instance Applicative Down
  • instance Applicative Update
  • instance Applicative Optional
  • instance Applicative Formula
  • instance Applicative NonEmpty
  • instance Applicative (Validation err)
  • instance Applicative (Either e)
  • instance Applicative []

​
class Applicative m => Action m

Methods:
  • >>= : m a -> (a -> m b) -> m b Sequentially compose two actions, passing any value produced by the first as an argument to the second.
Instances:
  • instance Action (-> r)
  • instance Action (State s)
  • instance Action Down
  • instance Action Update
  • instance Action Optional
  • instance Action Formula
  • instance Action NonEmpty
  • instance Action (Either e)
  • instance Action []

​
class Action m => ActionFail m

This class exists to desugar pattern matches in do-notation. Polymorphic usage, or calling fail directly, is not recommended. Instead consider using CanAbort. Methods:
  • fail : Text -> m a Fail with an error message.
Instances:
  • instance ActionFail Update
  • instance ActionFail Optional
  • instance ActionFail (Either Text)
  • instance ActionFail []

​
class Semigroup a

The class of semigroups (types with an associative binary operation). Methods:
  • <> : a -> a -> a An associative operation.
Instances:
  • instance Ord k => Semigroup (Map k v)
  • instance Semigroup (TextMap b)
  • instance Semigroup All
  • instance Semigroup Any
  • instance Semigroup (Endo a)
  • instance Multiplicative a => Semigroup (Product a)
  • instance Additive a => Semigroup (Sum a)
  • instance Semigroup (NonEmpty a)
  • instance Ord a => Semigroup (Max a)
  • instance Ord a => Semigroup (Min a)
  • instance Ord k => Semigroup (Set k)
  • instance Semigroup (Validation err a)
  • instance Semigroup Ordering
  • instance Semigroup Text
  • instance Semigroup [a]

​
class Semigroup a => Monoid a

The class of monoids (types with an associative binary operation that has an identity). Methods:
  • mempty : a Identity of (<>)
  • mconcat : [a] -> a Fold a list using the monoid. For example using mconcat on a list of strings would concatenate all strings to one lone string.
Instances:
  • instance Ord k => Monoid (Map k v)
  • instance Monoid (TextMap b)
  • instance Monoid All
  • instance Monoid Any
  • instance Monoid (Endo a)
  • instance Multiplicative a => Monoid (Product a)
  • instance Additive a => Monoid (Sum a)
  • instance Ord k => Monoid (Set k)
  • instance Monoid Ordering
  • instance Monoid Text
  • instance Monoid [a]

​
class HasSignatory t

Exposes signatory function. Part of the Template constraint. Methods:
  • signatory : t -> [Party] The signatories of a contract.

​
class HasObserver t

Exposes observer function. Part of the Template constraint. Methods:
  • observer : t -> [Party] The observers of a contract.

​
class HasEnsure t

Exposes ensure function. Part of the Template constraint. Methods:
  • ensure : t -> Bool A predicate that must be true, otherwise contract creation will fail.

​
class HasCreate t

Exposes create function. Part of the Template constraint. Methods:
  • create : t -> Update (ContractId t) Create a contract based on a template t.

​
class HasFetch t

Exposes fetch function. Part of the Template constraint. Methods:
  • fetch : ContractId t -> Update t Fetch the contract data associated with the given contract ID. If the ContractId t supplied is not the contract ID of an active contract, this fails and aborts the entire transaction.

​
class HasSoftFetch t

Exposes softFetch function

​
class HasSoftExercise t c r

​
class HasArchive t

Exposes archive function. Part of the Template constraint. Methods:
  • archive : ContractId t -> Update () Archive the contract with the given contract ID.

​
class HasTemplateTypeRep t

Exposes templateTypeRep function in Daml-LF 1.7 or later. Part of the Template constraint.

​
class HasToAnyTemplate t

Exposes toAnyTemplate function in Daml-LF 1.7 or later. Part of the Template constraint.

​
class HasFromAnyTemplate t

Exposes fromAnyTemplate function in Daml-LF 1.7 or later. Part of the Template constraint.

​
class HasExercise t c r

Exposes exercise function. Part of the Choice constraint. Methods:
  • exercise : ContractId t -> c -> Update r Exercise a choice on the contract with the given contract ID.

​
class HasChoiceController t c

Exposes choiceController function. Part of the Choice constraint.

​
class HasChoiceObserver t c

Exposes choiceObserver function. Part of the Choice constraint.

​
class HasExerciseGuarded t c r

(1.dev only) Exposes exerciseGuarded function. Only available for interface choices. Methods:
  • exerciseGuarded : (t -> Bool) -> ContractId t -> c -> Update r (1.dev only) Exercise a choice on the contract with the given contract ID, only if the predicate returns True.

​
class HasToAnyChoice t c r

Exposes toAnyChoice function for Daml-LF 1.7 or later. Part of the Choice constraint.

​
class HasFromAnyChoice t c r

Exposes fromAnyChoice function for Daml-LF 1.7 or later. Part of the Choice constraint.

​
class HasKey t k

Exposes key function. Part of the TemplateKey constraint. Methods:
  • key : t -> k The key of a contract.

​
class HasLookupByKey t k

Exposes lookupByKey function. Part of the TemplateKey constraint. Methods:
  • lookupByKey : k -> Update (Optional (ContractId t)) Look up the contract ID t associated with a given contract key k. You must pass the t using an explicit type application. For instance, if you want to look up a contract of template Account by its key k, you must call lookupByKey @Account k.

​
class HasFetchByKey t k

Exposes fetchByKey function. Part of the TemplateKey constraint. Methods:
  • fetchByKey : k -> Update (ContractId t, t) Fetch the contract ID and contract data associated with a given contract key. You must pass the t using an explicit type application. For instance, if you want to fetch a contract of template Account by its key k, you must call fetchByKey @Account k.

​
class HasMaintainer t k

Exposes maintainer function. Part of the TemplateKey constraint.

​
class HasToAnyContractKey t k

Exposes toAnyContractKey function in Daml-LF 1.7 or later. Part of the TemplateKey constraint.

​
class HasFromAnyContractKey t k

Exposes fromAnyContractKey function in Daml-LF 1.7 or later. Part of the TemplateKey constraint.

​
class HasExerciseByKey t k c r

Exposes exerciseByKey function.

​
class IsParties a

Accepted ways to specify a list of parties: either a single party, or a list of parties. Methods:
  • toParties : a -> [Party] Convert to list of parties.
Instances:
  • instance IsParties Party
  • instance IsParties (Optional Party)
  • instance IsParties (NonEmpty Party)
  • instance IsParties (Set Party)
  • instance IsParties [Party]

​
Functions

​
assert

assert : CanAssert m => Bool -> m ()
Check whether a condition is true. If it’s not, abort the transaction.

​
assertMsg

assertMsg : CanAssert m => Text -> Bool -> m ()
Check whether a condition is true. If it’s not, abort the transaction with a message.

​
assertAfter

assertAfter : (CanAssert m, HasTime m) => Time -> m ()
Check whether the given time is in the future. If it’s not, abort the transaction.

​
assertBefore

assertBefore : (CanAssert m, HasTime m) => Time -> m ()
Check whether the given time is in the past. If it’s not, abort the transaction.

​
daysSinceEpochToDate

daysSinceEpochToDate : Int -> Date
Convert from number of days since epoch (i.e. the number of days since January 1, 1970) to a date.

​
dateToDaysSinceEpoch

dateToDaysSinceEpoch : Date -> Int
Convert from a date to number of days from epoch (i.e. the number of days since January 1, 1970).

​
interfaceTypeRep

interfaceTypeRep : HasInterfaceTypeRep i => i -> TemplateTypeRep
(Daml-LF >= 1.15) Obtain the TemplateTypeRep for the template given in the interface value.

​
toInterface

toInterface : HasToInterface t i => t -> i
(Daml-LF >= 1.15) Convert a template value into an interface value. For example toInterface @MyInterface value converts a template value into a MyInterface type.

​
toInterfaceContractId

toInterfaceContractId : HasToInterface t i => ContractId t -> ContractId i
(Daml-LF >= 1.15) Convert a template contract id into an interface contract id. For example, toInterfaceContractId @MyInterface cid.

​
fromInterfaceContractId

fromInterfaceContractId : HasFromInterface t i => ContractId i -> ContractId t
(Daml-LF >= 1.15) Convert an interface contract id into a template contract id. For example, fromInterfaceContractId @MyTemplate cid. Can also be used to convert an interface contract id into a contract id of one of its requiring interfaces. This function does not verify that the interface contract id actually points to a template of the given type. This means that a subsequent fetch, exercise, or archive may fail, if, for example, the contract id points to a contract that implements the interface but is of a different template type than expected. Therefore, you should only use fromInterfaceContractId in situations where you already know that the contract id points to a contract of the right template type. You can also use it in situations where you will fetch, exercise, or archive the contract right away, when a transaction failure is the appropriate response to the contract having the wrong template type. In all other cases, consider using fetchFromInterface instead.

​
coerceInterfaceContractId

coerceInterfaceContractId : (HasInterfaceTypeRep i, HasInterfaceTypeRep j) => ContractId i -> ContractId j
(Daml-LF >= 1.15) Convert an interface contract id into a contract id of a different interface. For example, given two interfaces Source and Target, and cid : ContractId Source, coerceInterfaceContractId @Target @Source cid : ContractId Target. This function does not verify that the contract id actually points to a contract that implements either interface. This means that a subsequent fetch, exercise, or archive may fail, if, for example, the contract id points to a contract of template A but it was coerced into a ContractId B where B is an interface and there’s no interface instance B for A. Therefore, you should only use coerceInterfaceContractId in situations where you already know that the contract id points to a contract of the right type. You can also use it in situations where you will fetch, exercise, or archive the contract right away, when a transaction failure is the appropriate response to the contract having the wrong type.

​
fetchFromInterface

fetchFromInterface : (HasFromInterface t i, HasFetch i) => ContractId i -> Update (Optional (ContractId t, t))
(Daml-LF >= 1.15) Fetch an interface and convert it to a specific template type. If conversion is succesful, this function returns the converted contract and its converted contract id. Otherwise, this function returns None. Can also be used to fetch and convert an interface contract id into a contract and contract id of one of its requiring interfaces. Example: 
do
  fetchResult <- fetchFromInterface @MyTemplate ifaceCid
  case fetchResult of
    None -> abort "Failed to convert interface to appropriate template type"
    Some (tplCid, tpl) -> do
       ... do something with tpl and tplCid ...

​
_exerciseInterfaceGuard

_exerciseInterfaceGuard : a -> b -> c -> Bool

​
view

view : HasInterfaceView i v => i -> v

​
partyToText

partyToText : Party -> Text
Convert the Party to Text, giving back what you passed to getParty. In most cases, you should use show instead. show wraps the party in 'ticks' making it clear it was a Party originally.

​
partyFromText

partyFromText : Text -> Optional Party
Converts a Text to Party. It returns None if the provided text contains any forbidden characters. See Daml-LF spec for a specification on which characters are allowed in parties. Note that this function accepts text without single quotes. This function does not check on whether the provided text corresponds to a party that “exists” on a given ledger: it merely converts the given Text to a Party. The only way to guarantee that a given Party exists on a given ledger is to involve it in a contract. This function, together with partyToText, forms an isomorphism between valid party strings and parties. In other words, the following equations hold: 
∀ p. partyFromText (partyToText p) = Some p
∀ txt p. partyFromText txt = Some p ==> partyToText p = txt
This function will crash at runtime if you compile Daml to Daml-LF < 1.2.

​
coerceContractId

coerceContractId : ContractId a -> ContractId b
Used to convert the type index of a ContractId, since they are just pointers. Note that subsequent fetches and exercises might fail if the template of the contract on the ledger doesn’t match.

​
curry

curry : ((a, b) -> c) -> a -> b -> c
Turn a function that takes a pair into a function that takes two arguments.

​
uncurry

uncurry : (a -> b -> c) -> (a, b) -> c
Turn a function that takes two arguments into a function that takes a pair.

​
>>

>> : Action m => m a -> m b -> m b
Sequentially compose two actions, discarding any value produced by the first. This is like sequencing operators (such as the semicolon) in imperative languages.

​
ap

ap : Applicative f => f (a -> b) -> f a -> f b
Synonym for <*>.

​
return

return : Applicative m => a -> m a
Inject a value into the monadic type. For example, for Update and a value of type a, return would give you an Update a.

​
join

join : Action m => m (m a) -> m a
Collapses nested actions into a single action.

​
identity

identity : a -> a
The identity function.

​
guard

guard : ActionFail m => Bool -> m ()

​
foldl

foldl : (b -> a -> b) -> b -> [a] -> b
This function is a left fold, which you can use to inspect/analyse/consume lists. foldl f i xs performs a left fold over the list xs using the function f, using the starting value i. Examples: 
>>> foldl (+) 0 [1,2,3]
6

>>> foldl (^) 10 [2,3]
1000000
Note that foldl works from left-to-right over the list arguments.

​
find

find : (a -> Bool) -> [a] -> Optional a
find p xs finds the first element of the list xs where the predicate p is true. There might not be such an element, which is why this function returns an Optional a.

​
length

length : [a] -> Int
Gives the length of the list.

​
any

any : (a -> Bool) -> [a] -> Bool
Are there any elements in the list where the predicate is true? any p xs is True if p holds for at least one element of xs.

​
all

all : (a -> Bool) -> [a] -> Bool
Is the predicate true for all of the elements in the list? all p xs is True if p holds for every element of xs.

​
or

or : [Bool] -> Bool
Is at least one of elements in a list of Bool true? or bs is True if at least one element of bs is True.

​
and

and : [Bool] -> Bool
Is every element in a list of Bool true? and bs is True if every element of bs is True.

​
elem

elem : Eq a => a -> [a] -> Bool
Does this value exist in this list? elem x xs is True if x is an element of the list xs.

​
notElem

notElem : Eq a => a -> [a] -> Bool
Negation of elem: elem x xs is True if x is not an element of the list xs.

​
<$>

<$> : Functor f => (a -> b) -> f a -> f b
Synonym for fmap.

​
optional

optional : b -> (a -> b) -> Optional a -> b
The optional function takes a default value, a function, and a Optional value. If the Optional value is None, the function returns the default value. Otherwise, it applies the function to the value inside the Some and returns the result. Basic usage examples: 
>>> optional False (> 2) (Some 3)
True

>>> optional False (> 2) None
False

>>> optional 0 (*2) (Some 5)
10
>>> optional 0 (*2) None
0
This example applies show to a Optional Int. If you have Some n, this shows the underlying Int, n. But if you have None, this returns the empty string instead of (for example) None: 
>>> optional "" show (Some 5)
"5"
>>> optional "" show (None : Optional Int)
""

​
either

either : (a -> c) -> (b -> c) -> Either a b -> c
The either function provides case analysis for the Either type. If the value is Left a, it applies the first function to a; if it is Right b, it applies the second function to b. Examples: This example has two values of type Either [Int] Int, one using the Left constructor and another using the Right constructor. Then it applies either the length function (if it has a [Int]) or the “times-two” function (if it has an Int): 
>>> let s = Left [1,2,3] : Either [Int] Int in either length (*2) s
3
>>> let n = Right 3 : Either [Int] Int in either length (*2) n
6

​
concat

concat : [[a]] -> [a]
Take a list of lists and concatenate those lists into one list.

​
++

++ : [a] -> [a] -> [a]
Concatenate two lists.

​
flip

flip : (a -> b -> c) -> b -> a -> c
Flip the order of the arguments of a two argument function.

​
reverse

reverse : [a] -> [a]
Reverse a list.

​
mapA

mapA : Applicative m => (a -> m b) -> [a] -> m [b]
Apply an applicative function to each element of a list.

​
forA

forA : Applicative m => [a] -> (a -> m b) -> m [b]
forA is mapA with its arguments flipped.

​
sequence

sequence : Applicative m => [m a] -> m [a]
Perform a list of actions in sequence and collect the results.

​
=<<

=<< : Action m => (a -> m b) -> m a -> m b
=<< is >>= with its arguments flipped.

​
concatMap

concatMap : (a -> [b]) -> [a] -> [b]
Map a function over each element of a list, and concatenate all the results.

​
replicate

replicate : Int -> a -> [a]
replicate i x gives the list [x, x, x, ..., x] with i copies of x.

​
take

take : Int -> [a] -> [a]
Take the first n elements of a list.

​
drop

drop : Int -> [a] -> [a]
Drop the first n elements of a list.

​
splitAt

splitAt : Int -> [a] -> ([a], [a])
Split a list at a given index.

​
takeWhile

takeWhile : (a -> Bool) -> [a] -> [a]
Take elements from a list while the predicate holds.

​
dropWhile

dropWhile : (a -> Bool) -> [a] -> [a]
Drop elements from a list while the predicate holds.

​
span

span : (a -> Bool) -> [a] -> ([a], [a])
span p xs is equivalent to (takeWhile p xs, dropWhile p xs).

​
partition

partition : (a -> Bool) -> [a] -> ([a], [a])
The partition function takes a predicate, a list and returns the pair of lists of elements which do and do not satisfy the predicate, respectively; i.e.,
partition p xs == (filter p xs, filter (not . p) xs) 
>>> partition (<0) [1, -2, -3, 4, -5, 6]
([-2, -3, -5], [1, 4, 6])

​
break

break : (a -> Bool) -> [a] -> ([a], [a])
Break a list into two, just before the first element where the predicate holds. break p xs is equivalent to span (not . p) xs.

​
lookup

lookup : Eq a => a -> [(a, b)] -> Optional b
Look up the first element with a matching key.

​
enumerate

enumerate : (Enum a, Bounded a) => [a]
Generate a list containing all values of a given enumeration.

​
zip

zip : [a] -> [b] -> [(a, b)]
zip takes two lists and returns a list of corresponding pairs. If one list is shorter, the excess elements of the longer list are discarded.

​
zip3

zip3 : [a] -> [b] -> [c] -> [(a, b, c)]
zip3 takes three lists and returns a list of triples, analogous to zip.

​
zipWith

zipWith : (a -> b -> c) -> [a] -> [b] -> [c]
zipWith takes a function and two lists. It generalises zip by combining elements using the function, instead of forming pairs. If one list is shorter, the excess elements of the longer list are discarded.

​
zipWith3

zipWith3 : (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 generalises zip3 by combining elements using the function, instead of forming triples.

​
unzip

unzip : [(a, b)] -> ([a], [b])
Turn a list of pairs into a pair of lists.

​
unzip3

unzip3 : [(a, b, c)] -> ([a], [b], [c])
Turn a list of triples into a triple of lists.

​
traceRaw

traceRaw : Text -> a -> a
traceRaw msg a prints msg and returns a, for debugging purposes. The default configuration on the participant logs these messages at DEBUG level.

​
trace

trace : Show b => b -> a -> a
trace b a prints b and returns a, for debugging purposes. The default configuration on the participant logs these messages at DEBUG level.

​
traceId

traceId : Show b => b -> b
traceId a prints a and returns a, for debugging purposes. The default configuration on the participant logs these messages at DEBUG level.

​
debug

debug : (Show b, Action m) => b -> m ()
debug x prints x for debugging purposes. The default configuration on the participant logs these messages at DEBUG level.

​
debugRaw

debugRaw : Action m => Text -> m ()
debugRaw msg prints msg for debugging purposes. The default configuration on the participant logs these messages at DEBUG level.

​
fst

fst : (a, b) -> a
Return the first element of a tuple.

​
snd

snd : (a, b) -> b
Return the second element of a tuple.

​
truncate

truncate : Numeric n -> Int
truncate x rounds x toward zero.

​
intToNumeric

intToNumeric : NumericScale n => Int -> Numeric n
Convert an Int to a Numeric.

​
intToDecimal

intToDecimal : Int -> Decimal
Convert an Int to a Decimal.

​
roundBankers

roundBankers : Int -> Numeric n -> Numeric n
Bankers’ Rounding: roundBankers dp x rounds x to dp decimal places, where a .5 is rounded to the nearest even digit.

​
roundCommercial

roundCommercial : NumericScale n => Int -> Numeric n -> Numeric n
Commercial Rounding: roundCommercial dp x rounds x to dp decimal places, where a .5 is rounded away from zero.

​
round

round : NumericScale n => Numeric n -> Int
Round a Numeric to the nearest integer, where a .5 is rounded away from zero.

​
floor

floor : NumericScale n => Numeric n -> Int
Round a Decimal down to the nearest integer.

​
ceiling

ceiling : NumericScale n => Numeric n -> Int
Round a Decimal up to the nearest integer.

​
null

null : [a] -> Bool
Is the list empty? null xs is true if xs is the empty list.

​
filter

filter : (a -> Bool) -> [a] -> [a]
Filters the list using the function: keep only the elements where the predicate holds.

​
sum

sum : Additive a => [a] -> a
Add together all the elements in the list.

​
product

product : Multiplicative a => [a] -> a
Multiply all the elements in the list together.

​
undefined

undefined : a
A convenience function that can be used to mark something not implemented. Always throws an error with “Not implemented.”

​
softFetch

softFetch : HasSoftFetch t => ContractId t -> Update t

​
softExercise

softExercise : HasSoftExercise t c r => ContractId t -> c -> Update r

​
stakeholder

stakeholder : (HasSignatory t, HasObserver t) => t -> [Party]
The stakeholders of a contract: its signatories and observers.

​
maintainer

maintainer : HasMaintainer t k => k -> [Party]
The list of maintainers of a contract key.

​
exerciseByKey

exerciseByKey : HasExerciseByKey t k c r => k -> c -> Update r
Exercise a choice on the contract associated with the given key. You must pass the t using an explicit type application. For instance, if you want to exercise a choice Withdraw on a contract of template Account given by its key k, you must call exerciseByKey @Account k Withdraw.

​
createAndExercise

createAndExercise : (HasCreate t, HasExercise t c r) => t -> c -> Update r
Create a contract and exercise the choice on the newly created contract.

​
templateTypeRep

templateTypeRep : HasTemplateTypeRep t => TemplateTypeRep
Generate a unique textual representation of the template id.

​
toAnyTemplate

toAnyTemplate : HasToAnyTemplate t => t -> AnyTemplate
Wrap the template in AnyTemplate. Only available for Daml-LF 1.7 or later.

​
fromAnyTemplate

fromAnyTemplate : HasFromAnyTemplate t => AnyTemplate -> Optional t
Extract the underlying template from AnyTemplate if the type matches or return None. Only available for Daml-LF 1.7 or later.

​
toAnyChoice

toAnyChoice : (HasTemplateTypeRep t, HasToAnyChoice t c r) => c -> AnyChoice
Wrap a choice in AnyChoice. You must pass the template type t using an explicit type application. For example toAnyChoice @Account Withdraw. Only available for Daml-LF 1.7 or later.

​
fromAnyChoice

fromAnyChoice : (HasTemplateTypeRep t, HasFromAnyChoice t c r) => AnyChoice -> Optional c
Extract the underlying choice from AnyChoice if the template and choice types match, or return None. You must pass the template type t using an explicit type application. For example fromAnyChoice @Account choice. Only available for Daml-LF 1.7 or later.

​
toAnyContractKey

toAnyContractKey : (HasTemplateTypeRep t, HasToAnyContractKey t k) => k -> AnyContractKey
Wrap a contract key in AnyContractKey. You must pass the template type t using an explicit type application. For example toAnyContractKey @Proposal k. Only available for Daml-LF 1.7 or later.

​
fromAnyContractKey

fromAnyContractKey : (HasTemplateTypeRep t, HasFromAnyContractKey t k) => AnyContractKey -> Optional k
Extract the underlying key from AnyContractKey if the template and choice types match, or return None. You must pass the template type t using an explicit type application. For example fromAnyContractKey @Proposal k. Only available for Daml-LF 1.7 or later.

​
visibleByKey

visibleByKey : HasLookupByKey t k => k -> Update Bool
True if contract exists, submitter is a stakeholder, and all maintainers authorize. False if contract does not exist and all maintainers authorize. Fails otherwise.

​
Orphan Typeclass Instances

  • instance Eq a => Eq (Down a)
  • instance Show a => Show (Down a)
  • instance Functor Down
  • instance Functor a
  • instance Functor []
  • instance Functor (-> r)
  • instance Functor (Either e)
  • instance Ord a => Ord (Down a)
  • instance Ord TemplateTypeRep
  • instance Eq Archive
  • instance Show Archive
  • instance Eq AnyTemplate
  • instance Eq AnyChoice
  • instance Eq AnyContractKey
  • instance Ord AnyTemplate
  • instance Ord AnyChoice
  • instance Ord AnyContractKey
  • instance Eq TemplateTypeRep