@shd101wyy/yo 0.0.2

package/std/libc/unistd.yo

@@ -0,0 +1,130 @@
+c_include "<unistd.h>",
+  // Types
+  // usize : Type,
+  ssize_t : Type,
+  off_t : Type,
+  pid_t : Type,
+  uid_t : Type,
+  gid_t : Type,
+
+  // File descriptor operations
+  read :
+    (fn(fd : int, buf : *(unit), count : usize) -> ssize_t),
+  write :
+    (fn(fd : int, buf : *(unit), count : usize) -> ssize_t),
+  close :
+    (fn(fd : int) -> int),
+  lseek :
+    (fn(fd : int, offset : off_t, whence : int) -> off_t),
+  pipe :
+    (fn(pipefd : *(int)) -> int),
+  dup :
+    (fn(oldfd : int) -> int),
+  dup2 :
+    (fn(oldfd : int, newfd : int) -> int),
+
+  // Standard file descriptors
+  STDIN_FILENO : int,
+  STDOUT_FILENO : int,
+  STDERR_FILENO : int,
+
+  // File access
+  access :
+    (fn(pathname : *(char), mode : int) -> int),
+  unlink :
+    (fn(pathname : *(char)) -> int),
+  rmdir :
+    (fn(pathname : *(char)) -> int),
+  chdir :
+    (fn(path : *(char)) -> int),
+  getcwd :
+    (fn(buf : *(char), size : usize) -> ?*(char)),
+
+  // Process control
+  fork :
+    (fn() -> pid_t),
+  execve :
+    (fn(pathname : *(char), argv : *(*(char)), envp : *(*(char))) -> int),
+  _exit :
+    (fn(status : int) -> unit),
+  getpid :
+    (fn() -> pid_t),
+  getppid :
+    (fn() -> pid_t),
+
+  // User/Group IDs
+  getuid :
+    (fn() -> uid_t),
+  geteuid :
+    (fn() -> uid_t),
+  getgid :
+    (fn() -> gid_t),
+  getegid :
+    (fn() -> gid_t),
+
+  // Sleep
+  sleep :
+    (fn(seconds : u32) -> u32),
+  usleep :
+    (fn(usec : u32) -> int),
+
+  // File access modes for access()
+  R_OK : int,
+  W_OK : int,
+  X_OK : int,
+  F_OK : int
+;
+
+// Export all unistd functionality
+export
+  // Types
+  ssize_t,
+  off_t,
+  pid_t,
+  uid_t,
+  gid_t,
+
+  // File descriptor operations
+  read,
+  write,
+  close,
+  lseek,
+  pipe,
+  dup,
+  dup2,
+
+  // Standard file descriptors
+  STDIN_FILENO,
+  STDOUT_FILENO,
+  STDERR_FILENO,
+
+  // File access
+  access,
+  unlink,
+  rmdir,
+  chdir,
+  getcwd,
+
+  // Process control
+  fork,
+  execve,
+  _exit,
+  getpid,
+  getppid,
+
+  // User/Group IDs
+  getuid,
+  geteuid,
+  getgid,
+  getegid,
+
+  // Sleep
+  sleep,
+  usleep,
+
+  // File access modes
+  R_OK,
+  W_OK,
+  X_OK,
+  F_OK
+;

package/std/monad.yo

@@ -0,0 +1,152 @@
+/*
+Functor :: (fn(
+  compt(Wrapper) : (fn(compt(W) : Type) -> compt(Type))
+  ) -> compt(Module))
+  module(
+    map :
+      fn(
+        forall(A : Type, B : Type),
+        a : Wrapper(A),
+        f : (fn(a : A) => B)
+      ) -> Wrapper(B),
+    
+    (<$>) ?= Self.map
+  )
+;
+
+Apply :: (fn(
+  compt(Wrapper) : (fn(compt(W) : Type) -> compt(Type)),
+  using(FunctorInstance) : Functor(Wrapper)
+  ) -> compt(Module))
+  module(
+    ...(FunctorInstance),
+
+    (apply) : 
+      fn(
+        forall(A : Type, B : Type),
+        f : Wrapper(fn(a : A) => B),
+        a : Wrapper(A)
+      ) -> Wrapper(B),
+
+    (<*>) ?= apply
+  )
+;
+
+Applicative :: (fn(
+  compt(Wrapper) : (fn(compt(W) : Type) -> compt(Type)),
+  using(ApplyInstance) : Apply(Wrapper)
+  ) -> compt(Module))
+  module(
+    ...(ApplyInstance),
+
+    pure :
+      fn(
+        forall(A : Type),
+        a : A
+      ) -> Wrapper(A)
+  )
+;
+
+Bind :: (fn(
+  compt(Wrapper) : (fn(compt(W) : Type) -> compt(Type)),
+  using(ApplyInstance) : Apply(Wrapper)
+  ) -> compt(Module))
+  module(
+    ...(ApplyInstance),
+
+    (bind) : 
+      fn(
+        forall(A : Type, B : Type),
+        a : Wrapper(A),
+        f : (fn(a : A) => Wrapper(B))
+      ) -> Wrapper(B),
+
+    (>>=) ?= bind
+  )
+;
+
+Monad :: (fn(
+  compt(Wrapper) : (fn(compt(W) : Type) -> compt(Type)),
+  using(ApplicativeInstance) : Applicative(Wrapper),
+  using(BindInstance) : Bind(Wrapper)
+  ) -> compt(Module))
+  module(
+    ...(ApplicativeInstance),
+    ...(BindInstance)
+  )
+;
+
+Semigroup :: (fn(
+  compt(M) : Type
+  ) -> compt(Module))
+  module(
+    (append) : 
+      fn(
+        a : M,
+        b : M
+      ) -> M
+  )
+;
+
+Monoid :: (fn(
+  compt(M) : Type,
+  using(SemigroupInstance) : Semigroup(M)
+  ) -> compt(Module))
+  module(
+    ...(SemigroupInstance),
+
+    (empty) : 
+      fn() -> M
+  )
+;
+
+Foldable :: (fn(
+  compt(Wrapper) : (fn(compt(W) : Type) -> compt(Type))
+  ) -> compt(Module))
+  module(
+    foldr : 
+      fn(
+        forall(A : Type, B : Type),
+        a : Wrapper(A),
+        f : (fn(a : A, b : B) => B),
+        b0 : B
+      ) -> B,
+    foldl : 
+      fn(
+        forall(A : Type, B : Type),
+        a : Wrapper(A),
+        f : (fn(b : B, a : A) => B),
+        b0 : B
+      ) -> B,
+    fold_map :
+      fn(
+        forall(A : Type, M : Type),
+        a : Wrapper(A),
+        f : (fn(a : A) => M),
+        using(MonoidWrapper) : Monoid(M)
+      ) -> M
+  )
+;
+
+pure :: (fn(
+  forall(
+    A: Type,
+    Wrapper : (fn(compt(W) : Type) -> compt(Type))
+  ), 
+  a : A,
+  using(ApplicativeInstance) : Applicative(Wrapper)
+) -> Wrapper(A))
+  ApplicativeInstance.pure(a)
+;
+
+export
+  Functor,
+  Apply,
+  Applicative,
+  Bind,
+  Monad,
+  Monoid,
+  Foldable,
+  pure
+;
+*/