Zephir Blog @zephir-lang - Tumblr Blog

What's new in Zephir (VI)

Last weeks many improvements have been added to Zephir. We have nailed down a concrete list of features and are hard at work on implementing them. Zephir has gone through a long evolution. If you haven't looked at Zephir in a while, you may be now feel a better and stable version than early alpha versions.

Closures A very hard feature to implement is now available in Zephir. Closures allow to implement custom scopes of logic that are isolated of the current method and you can use to implement promises or just make them work as callbacks:

call_user_func(function() { echo "hello"; });

Alongside with built-in methods you can do amazing and elegant things as:

print_r([4, 8, 12, 32, 5]->map( function(int! x) { return x * x; } ));

Or use the short syntax for closures:

print_r([4, 8, 12, 32, 5]->map(x => x * x));

In plain PHP you need to do something like this:

print_r(array_map( function($x) { return $x * $x; }, [4, 8, 12, 32, 5] ));

Anonymous Variables A new useful warning was introduced recently in Zephir. It warns you whenever a variable is unused aside from its declaration:

public static function some(var v) { var z; if !empty v { let z = v; } }

Variable 'z' is assigned within the 'if' bloack however its value is never used:

Warning: Variable "z" assigned but not used in Zafiro\Functional::some in /Users/scott/zafiro/zafiro/functional.zep on 118 [unused-variable] let z = v; ------------------^

However, sometimes a language may require create unnecessary variables, in the case of Zephir, define these variables produces a warning when they are not used:

public static function some(var data) { var v; for v in data { echo "hello"; } }

Producing the following warning:

Warning: Variable "v" assigned but not used in Zafiro\Functional::some in /Users/scott/zafiro/zafiro/functional.zep on 117 [unused-variable] for v in data { ----------------^

How to avoid this warning if you really don't need that variable? Anonymous variables come to the rescue! To create an anonymous variable, you just have to use an underscore where required:

public static function some(var data) { for _ in data { echo "hello"; } }

This way the warning is gone, also you tell Zephir to avoid allocate unnecessary data or assignments.

Other uses of anonymous variables could be receive parameters in closures:

data->walk( function(_, int key) { echo key; } );

Windows Support We're near to fully support Zephir on Windows, currently you can generate the code of your extension and manually compile it using MS Visual C++. Keep in touch for a full guide about this topic.

References We're discussing the best way to implement references under the computational model of Zephir, you can give us your opinion here

Follow @zephirlang on Twitter for more updates

#zephir #php

What's new in Zephir (V)

These last weeks a lot of bugs have been fixed and new exciting features have been added to Zephir. Additionally, the core has been improved by adding namespaces, an autoloader, composer support and adopting PSR2 as coding standard. Main features added are highlighted as follows:

Parameters by Name

We have recently begun to implement parameters by name or keyword arguments. Check the description from Wikipedia out:

In computer programming, named parameters, pass-by-name, or keyword arguments refer to a computer language's support for function calls that clearly state the name of each parameter within the function call itself.

Named parameters can be useful if you want to pass parameters in an arbitrary order, document the meaning of parameters or specify parameters in a more elegant way.

Consider the following example, a class called "Image" has a method that receive four parameters:

class Image { public function chop(width=600, height=400, x=0, y=0) { //... } }

Using the standard way of calling methods:

i->chop(100); // width=100, height=400, x=0, y=0 i->chop(100, 50, 10, 20); // width=100, height=50, x=10, y=20

Using named parameters you can:

i->chop(width: 100); // width=100, height=400, x=0, y=0 i->chop(height: 200); // width=600, height=200, x=0, y=0 i->chop(height: 200, width: 100); // width=100, height=200, x=0, y=0 i->chop(x: 20, y: 30); // width=600, height=400, x=20, y=30

Do parameters by name make my extension slower?. This depends on how much information the compiler has on the method that is being called.

When the compiler has accurate knowledge of the class and method being called it simply check the parameters and orders them as they're expected:

let i = new Image(); i->chop(y:30, x: 20); // chop(null, null, 20, 30);

When the compiler (at compile time) does not know the correct order of these parameters they must be resolved at runtime, in this case there could be a minimum additional overhead:

let i = new {someClass}(); i->chop(y:30, x: 20);

Read-Only Parameters

Knowing in advance that parameters of a method will not be mutated (modifed) inside it offers advantages for the developer and the compiler. A developer can control that specific parameters will be not modified by mistake when this is not expected, see const correctness. Moreover, the compiler may in some cases generate more efficient code if it knows the value of a parameter is constant or inmutable:

class Utils { public function checkSum(const string! str) { char ch; int sum = 0; for ch in str { sum += ch->toInt(); } return sum; } }

Static Analysis

Another feature we are implementing is static analysis on conditional assignments. The idea is to help the developer to find potential problems and avoid unexpected behaviors.

class Utils { public function someMethod(b) { string a; char c; if b == 10 { let a = "hello"; } //a could be unitialized here for c in a { echo c, PHP_EOL; } } }

The above example illustrates a common situation. The variable "a" is assigned only when "b" is equal to 10, then it's required to use the value of this variable but it could be uninitialized. Zephir detects this and automatically initializes the variable to an empty string and generates a warning alerting the developer:

Warning: Variable 'a' was assigned for the first time in conditional branch, consider initialize it in its declaration in /home/scott/test/test/utils.zep on 21 [conditional-initialization] for c in a {

Finding such errors is sometimes tricky, however to the extent that static analysis can be improved, it will help the programmer to find bugs in advance.

That's all for now. See you soon!

#zephir #whats-new

What’s New in Zephir (IV)

This is our first post from the "What's New in Zephir" series after Zephir v0.3.0 was released and we have great improvements to share with you.

Bitwise operators

Rack Lin has implemented bitwise operators in Zephir allowing evaluation and manipulation of specific bits within an integer:

class Unicode { public function ord(string! c) { uchar ch; let ch = c[0]; if ch <= 0x7F { return ch; } if ch < 0xC2 { return false; } if ch <= 0xDF { return (ch & 0x1F) << 6 | (c[1] & 0x3F); } if ch <= 0xEF { return (ch & 0x0F) << 12 | (c[1] & 0x3F) << 6 | (c[2] & 0x3F); } if ch <= 0xF4 { return (ch & 0x0F) << 18 | (c[1] & 0x3F) << 12 | (c[2] & 0x3F) << 6 | (c[3] & 0x3F); } return false; } }

Bitwise operations are incredibly simple and thus usually faster than common arithmetic operations.

Built-In methods for Static Types

In Zephir, we have been always promoting object-oriented programming instead of procedural programming. Previously, static types in Zephir weren't encapsulating any kind of functionality associated to its type, therefore it was necessary to use procedural functions to manipulate or use these types:

class MyClass { public function getLength(string! someStr) { return strlen(someStr); } }

Now, you can just invoke a similar method directly from the static-typed variable:

class MyClass { public function getLength(string! someStr) { return someStr->length(); } }

Compare these two methods:

public function binaryTohex(string! s) -> string { var o = "", n; char ch; for ch in range(0, strlen(s)) { let n = sprintf("%X", ch); if strlen(n) < 2 { let o .= "0" . n; } else { let o .= n; } } return o; }

And:

public function binaryTohex(string! s) -> string { var o = "", n; char ch; for ch in range(0, s->length()) { let n = ch->toHex(); if n->length() < 2 { let o .= "0" . n; } else { let o .= n; } } return o; }

They both have the same functionality, but the second one uses object-oriented programming.

Thanks

Special thanks to Dmitry Patsura for contributing fixes and improvements to Zephir as well to all contributors.

Thank you all and see you next time!

#zephir #whats-new

Installing & Testing Zephir on Vagrant

Vagrant is an excellent tool you can use to create and deploy a linux-based development environment for your applications. In this tutorial, we are going to explain how to set it up for Zephir.

Setting up Vagrant

First of all you need Vagrant installed on your machine, this should be possible without major complications, in any case, check its documentation out if you fall in any trouble.

Once you have vagrant installed, a virtual machine can be installed this way:

$ vagrant init precise32 http://files.vagrantup.com/precise32.box $ vagrant up $ vagrant ssh

After this, you'll have a fully running Ubuntu (Precise Pangolin) linux. Now, you must be able to work inside an isolated development environment you can play with.

Required Packages

The following packages are needed to be installed in order to use Zephir.

$ sudo apt-get update $ sudo apt-get install git gcc make re2c php5 php5-dev libpcre3-dev

If you are working on any other debian-based distribution these instructions also might be useful.

Installing Zephir

Clone the repository and run the installer is enough to get Zephir running:

$ git clone https://github.com/phalcon/zephir $ cd zephir $ ./install -c $ cd ..

Testing Zephir

Now, we can create an skeleton for a simple extension:

$ zephir init utils

The following files are created:

$ ls utils/ config.json ext utils

Note that a directory called "utils" is created inside the skeleton directory also called "utils". This subdirectory is used to place the Zephir code. Now, let's create a simple class to test our extension:

// utils/utils/math.zep namespace Utils; class Math { public static function sum(int a, int b) { return a + b; } }

Enter the extension directory and compile the code:

$ cd utils $ zephir build

Edit the php.ini (/etc/php5/cli/php.ini) and append

extension=utils.so

Create a file test.php with the following to test the extension:

<?php echo Utils\Math::sum(100, 200), "\n";

If everything goes well you must see the following:

$ php test.php 300

Conclusion

It's easy to test Zephir in a Vagrant Box. Check the Zephir documentation to know what more is this language capable of.

#zephir #php #vagrant

Creating your first PHP extension with Zephir

This screencast explains how to use Zephir to create your first PHP extension. Check a written explanation for this screencast here

#zephir #php #phalcon

What's New in Zephir (III)

Welcome to the new edition of our "what's new" series. These days, more bugs have been fixed and a number of small improvements has been made here and there.

Polymorphic Return-Type Hints

Last week, we were implementing return-type hints, basically, with this feature, Zephir can know that a method returns a particular type of data or returns an instance of a specific class.

In the following example, we have a method returns that traverses a set of registered paths and return the first one that meet the property of being allowed:

public function getFirstAllowedPaths() -> <App\Path> { var path; for path in this->_paths { if path->isAllowed() == true { return path; } } }

In the previous method, Zephir will complaint because it reaches its end without returning a valid instance of <App\Path>. To fix this, a developer could throw an exception telling the user about this exceptional situation:

public function getFirstAllowedPaths() -> <App\Path> { var path; for path in this->_paths { if path->isAllowed() == true { return path; } } throw new App\Exception("error!!"); }

However, if there is no path that meets this condition, a developer may return "false" or "null" as a signal that no data is available (instead of throwing an exception).

By using polymorphic return-type hints a developer can specify more than one type of data or class instances allowed to be returned by the method.

public function getFirstAllowedPaths() -> <App\Path> | boolean { var path; for path in this->_paths { if path->isAllowed() == true { return path; } } return false; }

Strict/Flexible Parameter Data-Types

Another feature we're implementing is strict/flexible parameter data types. In Zephir, you can specify the data type of each parameter of a method.

By default, these data-types are flexible, this means that if a value with wrong (but compatible) data-type is passed, Zephir will try to transparently convert it to the expected one:

public function filterText(string text, boolean escape=false) { //... }

The above method will work with the following calls:

$o->filterText(1111, 1); // OK $o->filterText("some text", null); // OK $o->filterText(null, true); // OK $o->filterText("some text", true); // OK $o->filterText(array(1, 2, 3), true); // FAIL

However, passing a wrong type could be often leads to bugs, a bad use of a specific API would produce unexpected results. You can disallow the automatic conversion by setting the parameter with a strict data-type:

public function filterText(string! text, boolean escape=false) { //... }

Now, most of the calls with a wrong type will cause an exception due to the invalid data types passed:

$o->filterText(1111, 1); // FAIL $o->filterText("some text", null); // OK $o->filterText(null, true); // FAIL $o->filterText("some text", true); // OK $o->filterText(array(1, 2, 3), true); // FAIL

By specifying what parameters are strict and what must be flexible, a developer can set the specific behavior he/she really wants.

Return-Type: Void

From now, methods can be marked as 'void'. This means that a method is not allowed to return any data:

public function setConnection( connection) -> void { this->_connection = connection; }

Why is this useful? Because the compiler can detect if you're expecting a value from these methods and produce a compiler exception:

let myDb = db->setConnection(connection); myDb->execute("SELECT * FROM robots"); // this will produce an exception

Branch Prediction Hints

Now a developer can specify branch prediction hints. What is branch prediction? Check the Wikipedia article out. In environments where performance is very important, it may be useful to introduce these hints.

Consider the following example:

let allPaths = []; for path in this->_paths { if path->isAllowed() == false { throw new App\Exception("error!!"); } else { let allPaths[] = path; } }

We, as the authors of the above code, know in advance that the condition that throws the exception is unlikely to happen. This means that 99.9% of the time, our method executes that condition, but it is probably never evaluated as true. For the processor, this is hard to know, so we could introduce a hint there:

let allPaths = []; for path in this->_paths { if unlikely path->isAllowed() == false { throw new App\Exception("error!!"); } else { let allPaths[] = path; } }

Check also this article to know more about branch prediction.

This is all for this week, keep in touch for more updates!

#zephir #whats-new

What's New in Zephir (II)

Zephir development has been progressing at a steady pace and there are quite a few new things we're going to have a look at today.

Getter/Setter shortcuts

Like in C#, you can use get/set/toString shortcuts in Zephir, this feature allows to easily write setters and getters for properties without explictly implementing those methods as such.

For example, without shortcuts we could find code like:

<?php class MyClass { protected $myProperty; protected $someProperty = 10; public function setMyProperty($myProperty) { $this->myProperty = $myProperty; } public function getMyProperty() { return $this->myProperty; } public function setSomeProperty($someProperty) { $this->someProperty = $someProperty; } public function getSomeProperty() { return $this->someProperty; } public function __toString() { return $this->myProperty; } }

You can write the same code using shortcuts as follows:

namespace App; class MyClass { protected myProperty { set, get, toString }; protected someProperty = 10 { set, get } }

When the code is compiled those methods are exported as real methods but you don't have to write them one by one.

Return Type Hints

Now, methods in classes and interfaces can have return type hints, these will provide useful extra information to the compiler to inform you about errors in your application. Consider the following example:

namespace App; class MyClass { public function getSomeData() -> string { // this will throw a compiler exception // since the returned value (boolean) does not match // the expected returned type string return false; } public function getSomeOther() -> <App\MyInterface> { // this will throw a compiler exception // if the returned object does not implement // the expected interface App\MyInterface return new App\MyObject; } public function process() { var myObject; // the type-hint will tell the compiler that // myObject is an instance of a class // that implement App\MyInterface let myObject = this->getSomeOther(); // the compiler will check if App\MyInterface // implements a method called "someMethod" echo myObject->someMethod(); } }

That's it for this edition. Don't forget to go read the docs if you want to know more about Zephir and help us improve them :)

Thank you all and see you next time!

#zephir #whats-new

What's New in Zephir (I)

In the last weeks Zephir has seen a lot of new features, improvements, and bug fixes. In this little post we're going to highlight some of the most prominent ones:

Static Type Inference

We have implemented a multi-pass static type inference optimizer for Zephir. Basically, thanks to these passes, the compiler can automatically convert dynamic variables into static variables producing simpler and possibly best performant code.

Let's pretend we have the following code:

var a, b; int c; let a = "1", b = 2, c = b + a; return c;

There are clear opportunities to declare 'a' and 'b' as 'integer' variables, the compiler can address these opportunities producing better code without modifying the original behavior.

int a, b, c; a = 1; b = 2; c = (b + a); RETURN_LONG(c);

The compiler also performs an additional optimization called: Constant Propagation. Since 'a' and 'b' can be easily replaced by their constant values the final compiled code will be:

RETURN_LONG(3);

This example above showed how there was a code reduction starting from a high-level language representation.

Type Hints

Zephir always tries to check whether an object implements methods and properties called/accessed on a variable that is inferred to be an object:

let o = new MyObject(); // Zephir checks if "myMethod" is implemented on MyObject o->myMethod();

However, due to the dynamism inherited from PHP, sometimes it is not easy to know the class of an object so Zephir can not produce errors reports effectively. A "type hint" tells the compiler which class is related to a dynamic variable allowing the compiler to perform more compilation checks:

// Tell the compiler that "o" // is an instance of class MyClass let o = <MyClass> this->_myObject; o->myMethod();

Fetch Operator

'Fetch' is an operator that reduce a common operation in PHP into a single instruction:

<?php if (isset($myArray[$key])) { $value = $myArray[$key]; echo $value; }

In Zephir, you can write the same code as:

if fetch value, myArray[key] { echo value; }

'Fetch' only returns true if the 'key' is a valid item in the array, only in that case, 'value' is populated.

That's it for this week. Thank you all and see you next week.

#zephir #whats-new

Welcome to the Zephir Blog

Hi, welcome to the Zephir Language official blog. We plan to share articles, tutorials and tips from the community and the Zephir developers. All this interesting content will be available soon. We think you’re going to love it.

#zephir #php

Trending Blogs

Recently Viewed Blogs

Zephir Blog