Mario KB coleea

Installing Swift on Ubuntu 20.04

1. Install Depencies

“clang”[ˈklæŋ] is the compiler based on LLVM for C, C++, Objective-C, and Objective-C++. clang is needed to install in order to Swift. Run the following code in Ubuntu terminal.

Before installing swift “libpython2.7” and “libpython2.7-dev” are needed to get Swift running. Run the following code.

How to setup next.js app on nginx with letsencrypt

next.js, nginx, reverse-proxy, ssl

1. Install nginx and letsencrypt

$ sudo apt-get update
$ sudo apt-get install nginx letsencrypt

Also enable nginx in ufw

This tutorial explains how Unison handles 'effectful' computations, like storing state or performing I/O, using abilities. It assumes you haven't come across abilities before, and covers everything from the ground up.

This is an unofficial tutorial, written before the one on unisonweb.org/docs. The approach taken here is slow and methodical. Your first stop should be the official tutorial, if you haven't seen it already.

This doc is a Unison transcript - the source is here.

Terminology note: other languages with ability systems typically call them 'effect handlers' or 'algebraic effects', but many of the ideas are the same.

	package zero

	import izumi.reflect.Tag
	import Kyo.*
	import scala.collection.View.FlatMap

	type Id[T] = T
	type Const[T] = [U] =>> T
	type MX[T] = Any

	import * as S from '@effect/schema/Schema'
	import { Context, Effect } from 'effect'

	export interface IFetcher {
	fetch: typeof fetch
	}

	export const TFetcher = Context.Tag<IFetcher>('IFetcher')

	class FreshFetcher implements IFetcher {

	<!DOCTYPE html>
	<html>

	<head>
	<title>Hello Page</title>
	<script src="https://unpkg.com/[email protected]"></script>
	</head>

	<body>
	<h1>Hello</h1>

	import {
	useState,
	useCallback,
	useLayoutEffect,
	useRef,
	useEffect,
	} from 'react';

	const wait = () => new Promise((resolve) => setTimeout(resolve, 3000));

	// https://underscore.io/blog/posts/2015/04/23/deriving-the-free-monad.html

	// Example of implementing a specific instance of a free monad (for getting and
	// setting an integer value) in TypeScript. The type system is not expressive
	// enough to express free monads in general, but we can express a specific
	// instance.

	type AtomicOperation<T> = ["get", (x: number) => T] \| ["set", number, T];
	type Program<T> = ["return", T] \| ["suspend", AtomicOperation<Program<T>>];

	import React, { useState, useEffect, useCallback } from 'react';

	// Usage
	function App() {
	const { execute, status, value, error } = useAsync(myFunction, false);

	return (
	<div>
	{status === 'idle' && <div>Start your journey by clicking a button</div>}
	{status === 'success' && <div>{value}</div>}