gluon 0.13.1

A static, type inferred programming language for application embedding
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//@NO-IMPLICIT-PRELUDE
//! Functions for working with I/O

let io_prim @ { IO, File } = import! std.io.prim
let { Read } = import! std.io.read
let { Write } = import! std.io.write
let { Disposable } = import! std.disposable
let { Functor } = import! std.functor
let { Applicative } = import! std.applicative
let { Monad } = import! std.monad

/// Opens the file at `path` in read-only mode. Fails if the file does not
/// exist.
let open_file path : String -> IO File =
    let { OpenOptions } = io_prim
    io_prim.open_file_with path [Read]

/// Opens a file in write-only mode. If the file already exists, it will be
/// truncated. If the file does not exist, it will be created.
let create_file path : String -> IO File =
    let { OpenOptions } = io_prim
    io_prim.open_file_with path [Create, Write, Truncate]

let functor : Functor IO = {
    map = \f -> io_prim.flat_map (\x -> io_prim.wrap (f x))
}

let applicative : Applicative IO =
    let wrap = io_prim.wrap
    let apply f x = io_prim.flat_map (\g -> io_prim.flat_map (\y -> wrap (g y)) x) f

    { functor, apply, wrap }

let monad : Monad IO = {
    applicative = applicative,
    flat_map = io_prim.flat_map,
}

let read : Read File = {
    read = io_prim.read_file,
    read_to_end = io_prim.read_file_to_end,
}

let write : Write File = {
    write_slice = io_prim.write_slice_file,
    flush = io_prim.flush_file
}

let disposable : Disposable File = {
    dispose = io_prim.close_file,
    is_disposed = io_prim.is_file_closed,
}

{
    open_file,
    create_file,

    functor,
    applicative,
    monad,
    read,
    write,
    disposable,
    ..
    io_prim
}