dallaylaen

Sun Sep 15 02:29:55 CEST 2024

narrator: revisiting the Euclid's algorithm... One part was x->y->|x-y| which I implemented as x->y->(x dec y) inc (y dec x) (btw I hate succ/pred, it's only there to scare newbies away from FP) dec is derived somewhere around here but I can't find the record. it was identical to half below... so I noticed that x dec y can be writted as T dec x y and y dec x as V dec x y (here V x y z = z x y, impleemented as BCT, and T x y = y x implemented as CI) so how do I write T inc (T dec x y) (V dec x y) in a compact form?..

dallaylaen

#!/usr/bin/env perl

use strict;
use warnings;
use Test::Most;

my %days = (
    28 => qr/0[1-9]|1[0-9]|2[0-8]/,
    29 => qr/0[1-9]|[12][0-9]/,
    30 => qr/0[1-9]|[12][0-9]|30/,

dallaylaen

#!/usr/bin/env perl

=head1 DESCRIPTION

Executing a DESTROY block while returning from a nested try block has weird side effect
on the outer try block.

This may seem like a weird & unreachable case, but actually every Moo[se] module
has nonempty destructor.

dallaylaen

#!perl

use strict;
use warnings;

return 1 if caller; # before parsing args, output, input etc

print foo(); # side effect! 

sub foo {

dallaylaen

Unit tests are great. They show that the code was actually designed
to a given spec.

[Runtime](https://metacpan.org/pod/PerlX::Assert) [assertions](https://metacpan.org/pod/Devel::Assert)
are great. They show that the code is actually running the way it
was designed when applied to real data. 

[Design by contract](https://metacpan.org/pod/Class::Contract) is
a great concept, but it's a bit of an overkill for most projects.

dallaylaen

package nyt;

use strict;
use warnings;

=head1 NAME

nyt - Decorate existing code with Devel::NYTProf (for PSGI)

=head1 SYNOPSIS

dallaylaen

#!/usr/bin/perl

# If you use `xbindkeys` + `xsel`, here's how to make use of this script
# (it should be chmod +x and in your path, obviously)
#
#     "xsel -o | ruslat.pl | xsel -i"
#          Mod4 + q
#
# This maps the Super key (aka Win) + Q to this script and transcodes
# text in the clipboard

dallaylaen

class Contract {
    var log: List[Pair[Int,String]] = List()
    var count = 0
    var failed: List[Int] = List()
    var lock = false

    // MUTATORS 
    def refute( cond: Option[Any], message: String ): Boolean = {
        modif
        count += 1

dallaylaen

#!/bin/sh


getmod () {
curl -A "curl; used by https://metacpan.org/author/KHEDIN" \
    -XPOST https://fastapi.metacpan.org/v1/release/_search -d '{
  "size": 5000,
  "fields": [ "author", "name" ],
  "filter": {
    "and": [                                                   

dallaylaen

§ Введение в зависимо-типизированные алгебры

§§ Обыкновенные и матричные алгебры

Алгебры описываются в терминах грамматики и отношений взаимозаменяемости. В обыкновенных алгебрах (таких как моноид, группа, решётка, кольцо, поле) мы выделяем ровно один тип грамматических сущностей, но вообще говоря типов может быть много (напр. Существительное, Прилагательное, Глагол).

Чтобы ознакомиться с обозначениями, рассмотрим к примеру определение моноида:

                       a : M    b : M

–———– ——————— ————————————————