Arnau Abella monadplus

Web Authentication

Actors

A Relying Party: like github.com or google.com.
A User Agent: a browser or smartphone.
A Authenticator: security key manager.

Registration

If the pattern was strict, the tuples must have been evaluated to WHNF
forcing the whole list to be traversed before p x could be evaluated. This would not work on infinite lists nor bottom values.

partition :: (a -> Bool) -> [a] -> ([a],[a])
partition p xs = foldr (select p) ([],[]) xs
  where
    select :: (a -> Bool) -> a -> ([a], [a]) -> ([a], [a])
 select p x ~(ts,fs) | p x = (x:ts,fs)

Check nixpkgs/pkgs/build-support/trivial-builders.nix for more information about:

runCommand / runCommandCC
writeTextFile / writeTextDir
writeScript / writeScriptBin
writeShellScript / writeshellScriptBin
writeShellApplication
...

Create file docker-compose.yml (fix the parameters to your configuration):

version: "3.9"
services:
  bitcoin-core:
    container_name: bitcoin-server
    image: ruimarinho/bitcoin-core
    command:
      -printtoconsole

	#[macro_export]
	macro_rules! hash_map {
	($($key:expr => $val:expr),* ,) => (
	$crate::hash_map!($($key => $val),*)
	);
	($($key:expr => $val:expr),*) => {
	{
	let mut dict = ::std::collections::HashMap::new();
	$( dict.insert($key, $val); )*
	dict

	use std::{cmp::Ordering, fmt::Debug, marker::PhantomData, ops::Add};

	trait Nat {
	fn new() -> Self;
	fn usize() -> usize;
	}

	#[derive(Copy, Clone, PartialEq, Eq)]
	struct Z;

	// https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=c7d98a91435963f2cc8568b7dfd04366

	use std::fmt::Debug;

	trait MyTrait {
	type R: Debug;
	fn get_r(&self) -> Box<Self::R>;
	}

	#[derive(Debug)]

	{-# LANGUAGE RecordWildCards #-}
	module JsonSchema where

	import Control.Monad (unless, when, zipWithM_)
	import Data.Foldable (for_)
	import Data.Map.Strict (Map)
	import qualified Data.Map.Strict as Map
	import Data.Maybe (isJust, isNothing)

	type Key = String

	{-
	coerceFirst :: (Coercible a b) => [f a] -> Maybe (f b)
	coerceFirst [] = Nothing
	coerceFirst (x:_) = Just (coerce x)

	* Couldn't match representation of type `f a' with that of `f b'
	arising from a use of `coerce'
	NB: We cannot know what roles the parameters to `f' have;
	we must assume that the role is nominal

	{-# LANGUAGE AllowAmbiguousTypes #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE FlexibleContexts #-}
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE StandaloneKindSignatures #-}
	{-# LANGUAGE TypeApplications #-}
	{-# LANGUAGE TypeFamilies #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE UndecidableInstances #-}