CIAvash - Blog

Nature

CIAvash — Mon, 10 Apr 2023 00:00:00 +0000

You might think you have dodged a bullet
But you weren't the one getting shot barbarically

Statically, you've not moved an inch since you were born
Thinking others are doing the same, harmonically

You can't see beyond the tip of your nose which can only go so far
But the others were moving ahead; evolving naturally

Thinking not to worry, everything is under control
But things were getting out of your grasp, gradually

Your voice shouts lack of confidence
Although, followers will listen fanatically

Every time you take a break to catch your breath
Soon you realize it's only provisionally

You have one tool in your toolbox and it's a hammer
So you treat everything like a nail, anachronistically

We've entered a new era but you're unaware
So keep doing the same old tricks, habitually

I foresee that big changes are on their way
Not just domestically, but also internationally

But you keep telling yourself all is well
Not seeing that time is going by, exponentially

By the time you realize you're out of time
Nature will have taken care of you, eventually

flymake-rakudo - Another syntax checker for Raku on Emacs

CIAvash — Mon, 25 Apr 2022 00:00:00 +0000

Flymake

I've been switching to Emacs packages which are lighter and use the internal Emacs system, instead of creating their own. This time I wanted to try Flymake, the syntax checker that comes with Emacs. At first it wasn't very appealing because I thought it would only show the error on mouse hover! So I tried to see what options I have for displaying the error messages when text cursor moves over them.

Eldoc

The first step was using and tweaking Eldoc. Flymake shows errors by adding flymake-eldoc-function to eldoc-documentation-functions list. But by default Eldoc only shows one message at a time and the priority is with the order of the documentation functions.

Fortunately there is a customization option for showing messages. The name of this option is eldoc-documentation-strategy, you can see its values and change it using customize-group or customize-option commands. The value I was interested in was eldoc-documentation-compose; this function waits for all strings and then shows them. But changing this option is not enough if there are more than one messages, you have to change the eldoc-echo-area-use-multiline-p option as well; I set it to always.

Eglot

A word of caution! If you use Eglot(An LSP client), then make sure to add eldoc-documentation-strategy to its eglot-stay-out-of list. 'Cause Eglot sets it to eldoc-documentation-enthusiast which caused a lot of head scratching.

(add-to-list 'eglot-stay-out-of 'eldoc-documentation-strategy)

Eldoc-box

Now Eldoc can show all messages, documentation and Flymake diagnostics. But it shows them in the echo area. So I looked for a package to show it as a child frame. The package I found was eldoc-box.

Flymake-rakudo

Now that I could see Flymake as a viable option, I had to create a syntax checker for Raku using the Rakudo implementation, because that is the language I use most. Of course there is a flymake-flycheck package for using Flycheck checkers as Flymake backends and I could use it with flycheck-raku, but I decided to create one for Flymake. With a great timing, recently a package was released for Emacs which makes it easier to create Flymake checkers.

Flymake-collection

That package is flymake-collection, it provides a collection of Flymake checkers and helpers for creating checkers. At first I tried to use the regex from flycheck-raku, but then I saw that flymake-collection had flymake-collection-define-enumerate and flymake-collection-parse-json functions for creating a checker using JSON output. So I decided to set the RAKU_EXCEPTIONS_HANDLER environment variable to JSON and parse the output of that.

It wasn't an easy job at all, because I don't really know Emacs Lisp! And to create a flexible diagnostics generator, I had to work with Elisp's data structures. So I had no idea what I was doing! After playing with it for a while, reading the documentation and a lot of struggling, I learned a bit about association lists and managed to use them.

I also had to do a bit more because of how Rakudo outputs the errors; e.g. Parsing a JSON field separately, finding the error column from its position. But I finally did it and I'm happy with it so far. Of course it needs to be used more to find bugs or other special cases.

So there you have it: flymake-rakudo.

Final words

Even with all that, I hope we'll see a language server implementation for Raku.

How to write Raku's trans routine/operator in Go

CIAvash — Sun, 13 Feb 2022 00:00:00 +0000

I was looking for a way to transliterate(translate) English numbers to Persian numbers in Go. Such functionality is usually found in programming languages, but I wasn't expecting too much from Go.

It's very easy to do in Raku:

say 567.trans: '0'..'9' => '۰'..'۹'
=output ۵۶۷␤

say TR/0..9/۰..۹/ given 567
=output ۵۶۷␤

For Go I found xstrings module which has a Translate function. But the solution I came up with was using NewReplacer function from Go's internal strings module:

package main

import (
 "fmt"
 "strings"
)

func main() {
 fmt.Println(strings.NewReplacer(`0`, `۰`, `1`, `۱`, `2`, `۲`, `3`, `۳`, `4`, `۴`, `5`, `۵`, `6`, `۶`, `7`, `۷`, `8`, `۸`, `9`, `۹`).Replace(`567`))
}

Go playground link

This could be easier to write if Go had a zip function, so you could zip two slices (or ranges if Go had a range operator) and then use the ... unpack operator. Or Replacer could have a method that took two slices or better two ranges(that is, if Go had it), specially now that Generics are coming to Go.

Unrelated to the title of this blog post, I was also looking for a module to parse HTML documents using CSS selectors; my search led me to goquery. Which was what I wanted, but I couldn't find an easy way to get the whitespace-trimmed text content of HTML elements; there was a Text function, but that contained everything. It seems it's not just the way of thinking of the Go language that makes me want more, but also some Go modules. So I ended up writing a recursive function to trim whitespace using strings.TrimSpace and join texts.

This is how I would do it in Raku, using DOM::Tiny (also containing the previous code):

put $dom.find('.my-element > div').map(*.all-text(:trim)).join("\n").trans: '0'..'9' => '۰'..'۹';

And this is my Go solution(maybe there are better ways to do it, that I'm not aware of, or even better way to write my code):

// ........
 text := strings.Join(doc.Find(`.my-element > div`).Map(getText), "\n")

 text = strings.NewReplacer(`0`, `۰`, `1`, `۱`, `2`, `۲`, `3`, `۳`, `4`, `۴`, `5`, `۵`, `6`, `۶`, `7`, `۷`, `8`, `۸`, `9`, `۹`).Replace(text)

 fmt.Println(text)
// ........

func getText (_ int, s *goquery.Selection) string {
 if children := s.ChildrenFiltered(`:not(img)`); children.Text() != `` {
 return strings.Join(children.Map(getText), ` `)
 } else {
 return strings.TrimSpace(s.Text())
 }
}

Another solution is using the regexp module to replace all whitespace:

// ........
 text := strings.Join(doc.Find(`.my-element > div`).Map(func(_ int, s *goquery.Selection) string {
 re := regexp.MustCompile(`\s+`)
 return re.ReplaceAllLiteralString(s.Text(), ` `)
 }), "\n")

 text = strings.NewReplacer(`0`, `۰`, `1`, `۱`, `2`, `۲`, `3`, `۳`, `4`, `۴`, `5`, `۵`, `6`, `۶`, `7`, `۷`, `8`, `۸`, `9`, `۹`).Replace(text)

 fmt.Println(text)
// ........

What I get from Go is speed, so I won't complain too much 😀

And just for fun, I'm still seeing this when I visit https://pkg.go.dev :

T - Easy way of writing test assertions which output good test descriptions and error messages in Raku

CIAvash — Sun, 13 Feb 2022 00:00:00 +0000

After I finished watching Daniel Sockwell's FOSDEM 2022 Raku presentation, I thought this is a good opportunity to play with Raku's slangs, something I hadn't done before.

What is Daniel's talk(and upcoming module) and my module going to solve?

Write less but more readable test code
Get a useful test description and failure message

If you use cmp-ok, you get a good error message; but without a test description it's sometimes hard to understand. Also cmp-ok and other test functions(most of them, use-ok being an exception for example) do not output anything on a successful test, unless you provide the description yourself. I personally think that test sub routines should generate a description if one is not provided. But of course that cannot be done with simple functions. Maybe the Test module needs to be rethought in the future?

So I made the T slang which provides the t keyword for writing test assertions. I didn't want to make it complicated, so it's a very short and simple slang which takes an expression of form <got> <infix> <expected>.

The current status of the module: It works for me!

Here are some examples:

use T:auth<zef:CIAash>;

t 4 == 4;
=output ok 1 - 4 == 4

t $my_great_module.return('something') eq 'something';
=output ok 2 - $my_great_module.return('something') eq 'something'

t $my_great_module.return('something else') eq 'something';
=output not ok 3 - $my_great_module.return('something else') eq 'something'
# Failed test '$my_great_module.return('something else') eq 'something''
# at ... line ...
# expected: "something"
# matcher: 'infix:<eq>'
# got: "something else"

Raku, Go, Chroma, Germanium, Hugo and my blog

CIAvash — Mon, 05 Jul 2021 00:00:00 +0000

When I created my Raku programming language website with Hugo static site generator, I had to manually create the syntax highlighted html files for code examples shown in the front page, because Hugo used Chroma(written in Go and uses a mostly similar API to Pygments) for syntax highlighting which didn't support Raku. So I opened an issue on Chroma, the discussion showed that you cannot just convert the Raku lexer from Pygments to Chroma; You would need to create some functions manually, and Chroma needed a new Emitter interface which would take the LexerState as an argument, because Raku has some complex syntax; the Raku lexer in Pygments had functions for finding closing brackets matching the opening brackets, and for regex nesting in tokens, regexes and rules. In the end I realized functions for token nesting were unnecessary.

But I was curious if I could do something with the broken lexer I generated with the pygments2chroma.py script that comes with Chroma. So I began working on the Raku lexer without knowing Go, Chroma, Python or Pygments.

Chroma

After playing with the lexer for a while, I was very close to giving up. But after looking at the Chroma code and the functions it provided and also looking at some other lexers, I began to come up with some ideas.

For finding closing brackets I used the function generated by pygments2chroma and modified it a lot and also as a workaround I placed empty capture groups inside the patterns that needed bracket finding; and I filled those placeholders with the bracketsFinder function(or mutator).

I also used a placeholder rule inside regex which would be replaced by bracketsFinder with the appropriate rule which Poped from the regex state when the delimiter matched.

I did the same thing with POD formatters(C<code>, B<bold>,...), although I didn't have to, and could create a state for each formatter that needed different tokens for highlighting.

I also created Emitters for Raku's colon pair syntax and POD config.

So I finally managed to create an imperfect Raku lexer for Chroma.

I added some things to Chroma itself as well; Added support for named capture groups(although there is something people need to watch for. regexp2, the regex package Chroma uses, implements .Nets' regex engine which doesn't maintain the order of captures, in other words, the number capturing groups come first then named capturing groups are appended, which I found surprising, and made a pull request to add an option for maintaining the capture order (I don't know if it'll get merged), added the ByGroupNames helper function, and made the emitter functions take *LexerState as argument, so they have access to more things.

I should have done these things before I made the Raku lexer, so I could use them while I was making it, but at the time, I didn't know I could do it! And also improved the Svelte, SCSS and Fish lexers. Additionally, added two new styles, doom-one and doom-one2 which are inspired by Atom One and Doom Emacs's Doom One themes. You can use them in version 0.9.2.

Lastly, the things I learned Chroma command line tool can do(which of course you can find by running chroma --help):

Printing syntax highlighted files to terminal:

chroma  -f terminal256 -s doom-one source.raku

Generating SVG file:

chroma -s doom-one source.raku --svg > output.svg

Generating styled HTML files:

chroma -s doom-one --html --html-all-styles --html-lines source.raku > output.html

You can install Chroma with:

go install github.com/alecthomas/chroma@latest

Or if you use Arch Linux, you can install it from AUR.

Generate images from source code with Germanium

Germanium(written in Go) is an alternative to Silicon, which is written in Rust and uses Syntect which uses Sublime Text syntax definitions for syntax highlighting, which does not support Raku. Syntax definitions are written in YAML files, I don't know if you can put logic in there. Also they say they don't accept new packages! Maybe Syntect accepts packages in their submodule? I don't know.

Anyway, I added support for options choosing a style and also listing styles. Also changed the Chroma version in the dependencies, so new lexers and styles can be used in Germanium v1.2.0.

Generating images:

germanium -s doom-one -o output.png source.raku

You can install Germanium with:

go install github.com/matsuyoshi30/germanium@latest

Or if you use Arch Linux, you can install it from AUR.

Golang

While writing the lexer, I often felt frustrated, because I wanted some functionality and would search for it and find three things:

A GitHub issue with a proposal for what I wanted, which would be a closed issue and not implemented
A Stack Overflow answer which said: you can do it with "this long and manually written code"
A Stack Overflow answer which said: you can emulate it like this

Which made me make a joke about it.

Go, to me is the complete opposite of Raku. And yet even though I didn't like it and the frustration that came with it, strangely I began to kinda like it! I contributed to different Go projects in a relatively short time, that says something nice about Go. So I may actually try to learn it. Even though I see this when I visit their website(because of Google App Engine and sanctions! Google usually goes to the extreme).

Lastly, there are things the go command line tool doesn't provide(or maybe I'm unaware of it). Such as updating all modules installed globally(especially useful for command line apps).

Hugo and my blog

My blog was generated by Jekyll until now. I don't blog often, so I didn't have much motivation to migrate to Hugo, even though Hugo has more features. But I said what the heck, I created a lexer that Hugo uses so I might as well use it. Therefore, I migrated my blog to Hugo and even used some of its features, for example I created categories and tags, added TOC and used the markdown render hooks feature for headings to linkify them and images to linkify them to their sources which is useful when the image is large.

Raku lexer is available since Hugo v0.84.0.

Raku

Finally some syntax highlighting for Raku inside Hugo with random code from here and there:

#!/usr/bin/env raku

=head1 Raku syntax highlighting

=begin code :lang<go>
package main

import "fmt"

func main() {
 fmt.Println(`Hello, Raku`)
}
=end code

put 'Hello, Go!';

#`(
multi
line
comment
)

say qq｢some $scalar text｣;
say qww｢some $variable 'some other text' text｣;
say q:ww｢some $variable 'some other text' text｣;
say q:w｢some $variable 'some other text' text｣;
say qq:w｢some $variable 'some other text' text｣;
say Q:c｢some $variable 'some text' { 2 + 1 } text｣;
say q:a｢some @array[1] 'some text' { 2 + 1 } text｣;
say Q:a:c｢some @array 'some text' { 2 + 1 } text｣;
say Q[some \qq[$variable.method()] testing];
say 'some \qq[$variable.method()] testing';
say "some @array[2] %hash{'test'} $variable.method() func() testing";

use Some::Module:auth<author>:ver(v1.*.0+);

say X::SomeException;

#| B<Fibonacci> with multiple dispatch
multi sub fib (0 --> 0) {}
multi sub fib (1 --> 1) {}
multi sub fib (\n where * > 1) {
 fib(n - 1) + fib(n - 2)
}
say fib 10;
# OUTPUT: 55

# Indirect invocant
notes $trip: "Almost there";

LABEL:
for <a b c> {
 .put;
}

# Roles and classes
role Shape {
 method area { ... }

 method print_area {
 say "Area of {self.^name} is {self.area}.";
 }
}

class Rectangle does Shape {
 has $.width is required;
 has $.height is required;

 method area {
 $!width * $!height
 }
}

Rectangle.new(width => 5, height => 7).print_area;
# OUTPUT: Area of Rectangle is 35.

#| U<INI> Parser
grammar INIParser {
 token TOP { <block> <section>* }
 token section { <header> <block> }
 token header { '[' ~ ']' \w+ \n+ }
 token block { [<pair> | <comment>]* }
 rule pair { <key> '=' <value> }
 token comment { ';' \N* \n+ }
 token key { \w+ }
 token value { <-[\n ;]>+ }
}

my $match = INIParser.parse: q:to/END/;
; Comment
key1=value1
key2 = value2

; Section 1
[section1]
key3=value3
END

say $match<block><pair>[0]<value>;
# OUTPUT: ｢value1｣

say $match<section>[0]<block><pair>[0]<value>;
# OUTPUT: ｢value3｣

grammar Calculator {
 token TOP { <calc-op> }

 proto rule calc-op {*}
 rule calc-op:sym<add> { <num> '+' <num> }
 rule calc-op:sym<sub> { <num> '-' <num> }

 token num { \d+ }
}

class Calculations {
 method TOP ($/) { make $<calc-op>.made; }
 method calc-op:sym<add> ($/) { make [+] $<num>; }
 method calc-op:sym<sub> ($/) { make [-] $<num>; }
}

say Calculator.parse('2 + 3', actions => Calculations).made;
# OUTPUT: «5␤»

grammar G {
 rule TOP { <function-define> }
 rule function-define {
 'sub' <identifier>
 {
 say "func " ~ $<identifier>.made;
 make $<identifier>.made;
 }
 '(' <parameter> ')' '{' '}'
 { say "end " ~ $/.made; }
 }
 token identifier { \w+ { make ~$/; } }
 token parameter { \w+ { say "param " ~ $/; } }
}

G.parse('sub f ( a ) { }');
# OUTPUT: «func f␤param a␤end f␤»

# Inifinite and lazy list
my @fib = 0, 1, * + * ... ∞;
say @fib[^11];
# OUTPUT: (0 1 1 2 3 5 8 13 21 34 55)

# Feed operator
@fib[^20] ==> grep(&is-prime) ==> say();
# OUTPUT: (2 3 5 13 89 233 1597)

# Function composition
my &reverse_primes = &reverse ∘ &grep.assuming(&is-prime);
say reverse_primes ^20;
# OUTPUT: (19 17 13 11 7 5 3 2)

my @a = 1..4;
my @b = 'a'..'d';
# Zip two lists using Z meta operator
say @a Z @b;
# OUTPUT: ((1 a) (2 b) (3 c) (4 d))
say @a Z=> @b;
# OUTPUT: (1 => a 2 => b 3 => c 4 => d)

# Hyper Operators
say @b «~» @a;
# OUTPUT: [a1 b2 c3 d4]

# Junctions
say 'Find all the words starting with a lowercase vowel'.words.grep: *.starts-with: any <a e i o u>;
# OUTPUT: (all a)

ay '🦋'.chars;
# OUTPUT: 1
say '🦋'.codes;
# OUTPUT: 1
say '🦋'.encode.bytes;
# OUTPUT: 4

my $raku = 'راکو';
say $raku.chars;
# OUTPUT: 4
say $raku.uninames;
# OUTPUT: (ARABIC LETTER REH ARABIC LETTER ALEF ARABIC LETTER KEHEH ARABIC LETTER WAW)
say $raku.comb;
# OUTPUT: (ر ا ک و)
say +$raku.comb;
# OUTPUT: 4

subset ℕ of Int where * > 0;

sub f (ℕ $a, ℕ $b --> Array of ℕ) {
 Array[ℕ].new: $a², $b²;
}

say f 1,2;
# OUTPUT: [1 4]

# Native Types
my int @a = ^10_000_000;
say [+] @a;
# OUTPUT: 49999995000000

sub MAIN(
 Str $file where *.IO.f = 'file.dat', #= an existing file to frobnicate
 Int :size(:$length) = 24, #= length/size needed for frobnication
 Bool :$verbose, #= required verbosity
) {
 say $length if $length.defined;
 say $file if $file.defined;
 say 'Verbosity ', ($verbose ?? 'on' !! 'off');
}

# $ script-name
# Usage:
# script-name [--size|--length=<Int>] [--verbose] [<file>]

# [<file>] an existing file to frobnicate
# --size|--length=<Int> length/size needed for frobnication
# --verbose required verbosity

# Using NativeCall to access libnotify and show a notification
use NativeCall;

sub notify_init (str $appname --> int32) is native('notify') { * }
sub notify_uninit is native('notify') { * }
class NotifyNotification is repr('CPointer') { * }
sub notify_notification_new (str $summary, str $body, str $icon --> NotifyNotification) is native('notify') { * }
sub notify_notification_show (NotifyNotification) is native('notify') { * }

if notify_init 'MyApp' {
 notify_notification_show notify_notification_new 'My Notification', 'Notification Body', Str;
 notify_uninit;
}

# Concurrency
react {
 my $current-proc;
 whenever $script.watch.unique(:as(*.path), :expires(1)) {
 .kill with $current-proc;
 $current-proc = Proc::Async.new($*EXECUTABLE, $script);
 my $done = $current-proc.start;
 whenever $done {
 $current-proc = Nil;
 }
 }
}

my $modules-load = start @files
 .grep(/ \.(yaml|yml) $/)
 .sort(-*.s)
 .race(batch => 1, degree => 6)
 .map(-> $file {
 my $yaml = self!load-yaml($file, $schema, $problems);
 with $yaml {
 Easii::Model::Module.new(parsed => $yaml, source => $file.basename)
 }
 })
 .eager;


# Supply
my $bread-supplier = Supplier.new;
my $vegetable-supplier = Supplier.new;

my $supply = supply {
 whenever $bread-supplier.Supply {
 emit("We've got bread: " ~ $_);
 };
 whenever $vegetable-supplier.Supply {
 emit("We've got a vegetable: " ~ $_);
 };
}
$supply.tap(-> $v { say "$v" });

$vegetable-supplier.emit("Radish");
# OUTPUT: «We've got a vegetable: Radish␤» 
$bread-supplier.emit("Thick sliced");
# OUTPUT: «We've got bread: Thick sliced␤» 
$vegetable-supplier.emit("Lettuce");
# OUTPUT: «We've got a vegetable: Lettuce␤»

=finish
Goodbye!

An improved flycheck-raku now available on melpa [Emacs]

CIAvash — Tue, 16 Mar 2021 00:00:00 +0000

Recently I forked the flycheck-raku (by @widefox) to the Raku GitHub organization. And did some improvements to it and published it on melpa, so others can easily install and update it.

For those who don't know, flycheck is a tool for syntax checking Gnu Emacs buffers.

You can install flycheck-raku using use-package:

(use-package flychek-raku :ensure t)

New features

Project detection

Previously if you used flycheck-raku on a project, it would show errors on use SomeModule;, even though the module was in the lib directory of the project. And this would make flycheck kinda useless, because it wouldn't show further errors.

But in the new version of flycheck-raku, project root is detected and its lib directory is added to include path. So no more errors on valid modules.

Error pattern improvements

Full error messages

Previous versions of flycheck-raku would cut some long error messages. Now, error messages are fully shown.

Multi-line error messages

In the new version, multi-line error messages are fully shown.

Potential difficulties

New version shows potential difficulties; I've only seen one such error message and that is Redclaration of symbol $x.

MovieInfo - A web app for finding movie information and ratings

CIAvash — Sun, 16 Oct 2016 00:00:00 +0000

I wanted to create something that makes it easy for me to see movie ratings. I decided to create it as a SPA. In order to do so, I had to find a good framework. I looked at a few well known frameworks, but did not like any of them!

I was going to give up, but then I saw Elm. I had seen it being mentioned here and there, but I had never looked into it. So I decided to give it a try and started reading the guide and the docs. I liked what I saw, so I did a bit more reading before starting the project.

MovieInfo

I wanted the project to be very simple and light, so I created a simple interface, and used the OMDb API to show the necessary information.

In addition to ratings from IMDB, Rotten Tomatoes and Metacritic, I added an overall rating, which is the average of those ratings.

MovieInfo is released under GPLv3+ and its source code is available here.

Update: I Recreated the app with Svelte: MovieInfo

Get football information in your terminal with football

CIAvash — Thu, 12 May 2016 00:00:00 +0000

App::Football is a command line program I wrote in Raku. football lets you access information regarding football(soccer!) teams, leagues, tables, fixtures, scores and players.

It uses another module I wrote called WebService::FootballData which is a Raku interface for football-data.org API.

To install App::Football, you need to first install Raku and Zef, then run:

zef install App::Football

The README file has some useful examples, but here are more examples and screenshots:

football --team=bayern --fixtures --timeframe=p30 --venue=away

football --team=mancity --players

football --league=pl --table --matchday=37

How to type Raku unicode characters in Emacs

CIAvash — Sat, 09 Jan 2016 00:00:00 +0000

Raku programming language uses some unicode characters as operators, quotation marks, etc. In this post I'm going to explain how to type those characters in Emacs using input methods.

First, you might want to see a list of those characters and their ASCII equivalents here. There is also a doc for entering unicode characters. You may specifically want to look at XCompose for a system-wide solution.

There are at least two input methods you can use to enter the unicode characters used in Raku. rfc1345 and TeX.

To select an input method type C-x RET C-\ and to switch to an input method use C-u C-\. C-\ can be used to toggle input method.

After you select an input method, You have to use the prefix character it provides for typing special characters. & is the prefix used for rfc1345 and \, ^ and some other characters are used for TeX.

Example for typing λ:

rfc1345: &l*

TeX: \lambda

To see a list of character sequences for an input method, type C-h I.

You can change the default input method by setting the default-input-method variable:

(setq default-input-method 'TeX)

To add characters which are not available in an input method:

(eval-after-load "quail/latin-ltx"
 `(let ((quail-current-package (assoc "TeX" quail-package-alist)))
 (quail-define-rules ((append . t))
 ("\\lcb" ?｢)
 ("\\rcb" ?｣))))

Now with TeX method enabled, \lcb types '｢' and \rcb types '｣'.

Same thing for the rfc1345 input method:

(eval-after-load "quail/rfc1345"
 `(let ((quail-current-package (assoc "rfc1345" quail-package-alist)))
 (quail-define-rules ((append . t))
 ("&[" "｢")
 ("&]" "｣"))))

Now with the rfc1345 method you can type '｢' with &[ and type '｣' with &].

Another way of entering unicode characters is using C-x 8 RET which runs insert-char command. C-x 8 prefix key has shortcuts for some characters. For example, C-x 8 / / inserts ÷. To add your own characters:

(global-set-key (kbd "C-x 8 l") "λ")

or:

(global-set-key (kbd "C-x 8 l") (lambda () (interactive) (insert "λ")))

Now C-x 8 l inserts λ.

Below is a list of unicode characters used in Raku and their character sequences in rfc1345 and TeX.

Note: rfc1345 character mnemonics work in Vim too. You only need to replace & with Ctrl-K.

Character	C-x 8	rfc1345	TeX
«	`<`	`&<<`	`\flqq`
»	`>`	`&>>`	`\frqq`
×	`x`	`&*X`	`\times`
÷	`/ /`	`&-:`	`\div`
−	`_ -`	`&-2`	`\minus`
≤	`_ <`	`&=<`	`\le`
≥	`_ >`	`&>=`	`\ge`
≠	`/ =`	`&!=`	`\ne`
∘		`&Ob`	`\circ`
≅		`&?=`	`\cong`
π		`&p*`	`\pi`
τ		`&t*`	`\tau`
∞		`&00`	`\infty`
…		`&.3`	`\ldots`
‘	`[`	`&'6`	`\rq`
’	`]`	`&'9`	`\lq`
‚		`&.9`	`\glq`
“	`{`	`&"6`	`\ldq`
”	`}`	`&"9`	`\rdq`
„		`&:9`	`\glqq`
¯	`=`	`&'m`	`\={}`
⁻		`&-S`	`^-`
⁺		`&+S`	`^+`
⁰ - ⁹	`^ 1` - `^ 3`	`&0S` - `&9S`	`^0` - `^9`
½	`1 / 2`	`&12`	`\frac12`
∅		`&/0`	`\emptyset`
∈		`&(-`	`\in`
∉			`\notin`
∋		`&-)`	`\ni`
⊆		`&(_`	`\subseteq`
⊈			`\nsubseteq`
⊂		`&(C`	`\subset`
⊄			`\nsubset`
⊇		`&)_`	`\supseteq`
⊉			`\nsupseteq`
⊃		`&(C`	`\supset`
⊅			`\nsupset`
∪		`&)U`	`\cup`
∩		`&(U`	`\cap`
∖			`\setminus`
⊖			`\ominus`
⊎			`\uplus`
≡		`&=3`	`\equiv`
≢			`\nequiv`

Magrent 1.0 released [Firefox]

CIAvash — Wed, 04 Jun 2014 00:00:00 +0000

Magrent 1.0 adds context menu items to torrent info hash(when hash is selected) and The Pirate Bay torrent pages and links.

Changes in this version:

Add support for The Pirate Bay torrent URLs and links
Add context menu items for torrent info hashes
New design for Magrent panel
Use new action buttons(Australis) with backwards compatibility.
New icon
Notify user when torrent source is not accessible.
Add torrent source name to the notification title

Simple parser for C language

CIAvash — Tue, 02 Jul 2013 00:00:00 +0000

For a long time I'v wanted to push my Parser project which was a university project for Principles of Compiler Design course to GitHub. Now I’v found the time to do it and you can download it here.

2 years ago I started learning Perl, soon Perl became my favourite programming language. It was then that our professor gave us the scanner project for C language. He told us that we can use the programming language of our choice. We were also allowed to use regular expressions. So I thought Perl is the best language for writing the project. In a month I read Learning Perl book and other necessary stuff and became ready to write the scanner. Scanner was my first Perl project. When I gave the project to professor, he said that I was the first person who has written the project in Perl :)

After Scanner, professor gave us a simple C grammar for a parser project. I wrote that in Perl too. The result (with a little change) is here.

The used grammar exists in the documents directory. Along with other things that are produced from grammar: the LL(1) grammar after left factoring and left recursion removal, FIRST and FOLLOW sets and the parse table.

Take a look at the README.md for its usage and some dummy C code for using in scanner and parser.

Usage:

scanner:

./scanner.pl [file_name]

Output: Symbol Table (tokens)

parser:

./parser.pl [-s] [file_name]

Output: Table of parsing process

With -s switch you can also see the scanner's output.

Simple C Parser on GitHub

Restoring GRUB with Arch linux live CD

CIAvash — Tue, 11 Dec 2012 00:00:00 +0000

I had Arch linux on my computer and needed Windows for gaming; Windows installs its own boot loader, so I had to re-install grub. The following is what I did to restore grub.

I suppose that you know what you're doing! For example you need to know in which partition linux is installed.

Boot Arch linux from live CD.

Create a directory for chroot environment:

mkdir /mnt/root

Mount the root partition and other necessary device and file systems:

mount /dev/sda1 /mnt/root
cd /mnt/root
mount -o bind /dev dev/
mount -t proc proc proc/
mount -t sysfs sys sys/

It seems that on newer Arch releases(2012), you can use arch-chroot /mnt/root instead of the last 3 mount commands.

If you have a separate partition for boot, mount it:

mount /dev/[boot partition] boot/

Change the root:

chroot .

You can define another shell by adding it to the above command, like this:

chroot . /bin/bash

Generate grub.cfg file:

grub-mkconfig -o /boot/grub/grub.cfg

Install GRUB:

grub-install /dev/sda

Exit the chroot environment:

exit

Unmount filesystems and devices:

umount {dev,proc,sys,}

Unmount the root partition:

cd ..
umount root

And finally, you can reboot:

reboot

My move from Ubuntu to Arch Linux

CIAvash — Mon, 12 Nov 2012 00:00:00 +0000

About a month ago I decided to try a new linux distribution. I was using Ubuntu and was even waiting for Ubuntu 12.10. I chose Arch Linux for testing, and Installed it on my netbook. I really liked the installation process! Then I chose Xfce as Desktop Environment. After a few days I decided to move from Ubuntu to Arch Linux.

When I read an article about a window manager, I was reminded of Tiling Window Managers so I decided to check window managers before moving. After some reading and comparing, I chose xmonad as my window manager.

So I installed Arch Linux with xmonad. I spent a few days on installing softwares and configuring. You can see the result in the below picture.

There is still a lot to learn about Arch Linux and xmonad, but I know enough to do the things I need to do.

If you want to try Arch Linux, the Beginners' Guide is the best place to start.

This guide is a good start on configuring xmonad. Other useful links:

xmonad : a guided tour

Xmonad/Config archive – HaskellWiki

Some of the Applications I use:(updated)

Firefox
Thunderbird
GNU Emacs (text editor and more!)
Guake (terminal)
zsh (shell)
tmux (terminal multiplexer)
xmobar (status bar)
dmenu (application launcher)
dunst (notification daemon)
Krusader, Dolphin (file manager)
ncmpcpp (music player)
mpv (media player)
feh, ristretto (image viewer)
scrot (screenshot)
zathura (PDF viewer)
Liferea (feed reader)
syncthing, btsync, dropbox (sync, backup)